repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Symbol/LineEntry.h
|
<filename>SymbolExtractorAndRenamer/lldb/include/lldb/Symbol/LineEntry.h
//===-- LineEntry.h ---------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_LineEntry_h_
#define liblldb_LineEntry_h_
#include "lldb/Core/AddressRange.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h"
/// @brief A line table entry class.
//----------------------------------------------------------------------
struct LineEntry {
//------------------------------------------------------------------
/// Default constructor.
///
/// Initialize all member variables to invalid values.
//------------------------------------------------------------------
LineEntry();
LineEntry(const lldb::SectionSP §ion_sp, lldb::addr_t section_offset,
lldb::addr_t byte_size, const FileSpec &file, uint32_t _line,
uint16_t _column, bool _is_start_of_statement,
bool _is_start_of_basic_block, bool _is_prologue_end,
bool _is_epilogue_begin, bool _is_terminal_entry);
//------------------------------------------------------------------
/// Clear the object's state.
///
/// Clears all member variables to invalid values.
//------------------------------------------------------------------
void Clear();
//------------------------------------------------------------------
/// Dump a description of this object to a Stream.
///
/// Dump a description of the contents of this object to the
/// supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file
/// list so the line entry can dump the file name (since this
/// object contains a file index into the support file list).
///
/// @param[in] show_file
/// If \b true, display the filename with the line entry which
/// requires that the compile unit object \a comp_unit be a
/// valid pointer.
///
/// @param[in] style
/// The display style for the section offset address.
///
/// @return
/// Returns \b true if the address was able to be displayed
/// using \a style. File and load addresses may be unresolved
/// and it may not be possible to display a valid address value.
/// Returns \b false if the address was not able to be properly
/// dumped.
///
/// @see Address::DumpStyle
//------------------------------------------------------------------
bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style,
Address::DumpStyle fallback_style, bool show_range) const;
bool GetDescription(Stream *s, lldb::DescriptionLevel level, CompileUnit *cu,
Target *target, bool show_address_only) const;
//------------------------------------------------------------------
/// Dumps information specific to a process that stops at this
/// line entry to the supplied stream \a s.
///
/// @param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file
/// list so the line entry can dump the file name (since this
/// object contains a file index into the support file list).
///
/// @return
/// Returns \b true if the file and line were properly dumped,
/// \b false otherwise.
//------------------------------------------------------------------
bool DumpStopContext(Stream *s, bool show_fullpaths) const;
//------------------------------------------------------------------
/// Check if a line entry object is valid.
///
/// @return
/// Returns \b true if the line entry contains a valid section
/// offset address, file index, and line number, \b false
/// otherwise.
//------------------------------------------------------------------
bool IsValid() const;
//------------------------------------------------------------------
/// Compare two LineEntry objects.
///
/// @param[in] lhs
/// The Left Hand Side const LineEntry object reference.
///
/// @param[in] rhs
/// The Right Hand Side const LineEntry object reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const LineEntry &lhs, const LineEntry &rhs);
//------------------------------------------------------------------
/// Give the range for this LineEntry + any additional LineEntries for
/// this same source line that are contiguous.
///
/// A compiler may emit multiple line entries for a single source line,
/// e.g. to indicate subexpressions at different columns. This method
/// will get the AddressRange for all of the LineEntries for this source
/// line that are contiguous.
//
/// Line entries with a line number of 0 are treated specially - these
/// are compiler-generated line table entries that the user did not
/// write in their source code, and we want to skip past in the debugger.
/// If this LineEntry is for line 32, and the following LineEntry is for
/// line 0, we will extend the range to include the AddressRange of the
/// line 0 LineEntry (and it will include the range of the following
/// LineEntries that match either 32 or 0.)
///
/// If the initial LineEntry this method is called on is a line #0, only
/// the range of contiuous LineEntries with line #0 will be included in
/// the complete range.
///
/// @return
/// The contiguous AddressRange for this source line.
//------------------------------------------------------------------
AddressRange GetSameLineContiguousAddressRange() const;
//------------------------------------------------------------------
/// Apply file mappings from target.source-map to the LineEntry's file.
///
/// @param[in] target_sp
/// Shared pointer to the target this LineEntry belongs to.
//------------------------------------------------------------------
void ApplyFileMappings(lldb::TargetSP target_sp);
//------------------------------------------------------------------
// Member variables.
//------------------------------------------------------------------
AddressRange range; ///< The section offset address range for this line entry.
FileSpec file; ///< The source file, possibly mapped by the target.source-map
///setting
FileSpec original_file; ///< The original source file, from debug info.
uint32_t line; ///< The source line number, or zero if there is no line number
///information.
uint16_t column; ///< The column number of the source line, or zero if there
///is no column information.
uint16_t is_start_of_statement : 1, ///< Indicates this entry is the beginning
///of a statement.
is_start_of_basic_block : 1, ///< Indicates this entry is the beginning of
///a basic block.
is_prologue_end : 1, ///< Indicates this entry is one (of possibly many)
///where execution should be suspended for an entry
///breakpoint of a function.
is_epilogue_begin : 1, ///< Indicates this entry is one (of possibly many)
///where execution should be suspended for an exit
///breakpoint of a function.
is_terminal_entry : 1; ///< Indicates this entry is that of the first byte
///after the end of a sequence of target machine
///instructions.
};
//------------------------------------------------------------------
/// Less than operator.
///
/// @param[in] lhs
/// The Left Hand Side const LineEntry object reference.
///
/// @param[in] rhs
/// The Right Hand Side const LineEntry object reference.
///
/// @return
/// Returns \b true if lhs < rhs, false otherwise.
//------------------------------------------------------------------
bool operator<(const LineEntry &lhs, const LineEntry &rhs);
} // namespace lldb_private
#endif // liblldb_LineEntry_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Core/ValueObjectConstResultCast.h
|
<gh_stars>100-1000
//===-- ValueObjectConstResultCast.h ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ValueObjectConstResultCast_h_
#define liblldb_ValueObjectConstResultCast_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ValueObjectCast.h"
#include "lldb/Core/ValueObjectConstResultImpl.h"
namespace lldb_private {
class ValueObjectConstResultCast : public ValueObjectCast {
public:
ValueObjectConstResultCast(ValueObject &parent, const ConstString &name,
const CompilerType &cast_type,
lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
~ValueObjectConstResultCast() override;
lldb::ValueObjectSP Dereference(Error &error) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override;
virtual CompilerType GetCompilerType() {
return ValueObjectCast::GetCompilerType();
}
lldb::ValueObjectSP GetSyntheticChildAtOffset(
uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str = ConstString()) override;
lldb::ValueObjectSP AddressOf(Error &error) override;
size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
uint32_t item_count = 1) override;
lldb::ValueObjectSP Cast(const CompilerType &compiler_type) override;
protected:
ValueObjectConstResultImpl m_impl;
private:
friend class ValueObject;
friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl;
DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultCast);
};
} // namespace lldb_private
#endif // liblldb_ValueObjectConstResultCast_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Breakpoint/Breakpoint.h
|
<gh_stars>100-1000
//===-- Breakpoint.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Breakpoint_h_
#define liblldb_Breakpoint_h_
// C Includes
// C++ Includes
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointLocationList.h"
#include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Core/StringList.h"
#include "lldb/Core/StructuredData.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h"
/// @brief Class that manages logical breakpoint setting.
//----------------------------------------------------------------------
//----------------------------------------------------------------------
/// General Outline:
/// A breakpoint has four main parts, a filter, a resolver, the list of
/// breakpoint
/// locations that have been determined for the filter/resolver pair, and
/// finally
/// a set of options for the breakpoint.
///
/// \b Filter:
/// This is an object derived from SearchFilter. It manages the search
/// for breakpoint location matches through the symbols in the module list of
/// the target
/// that owns it. It also filters out locations based on whatever logic it
/// wants.
///
/// \b Resolver:
/// This is an object derived from BreakpointResolver. It provides a
/// callback to the filter that will find breakpoint locations. How it does
/// this is
/// determined by what kind of resolver it is.
///
/// The Breakpoint class also provides constructors for the common breakpoint
/// cases
/// which make the appropriate filter and resolver for you.
///
/// \b Location List:
/// This stores the breakpoint locations that have been determined
/// to date. For a given breakpoint, there will be only one location with a
/// given
/// address. Adding a location at an already taken address will just return the
/// location
/// already at that address. Locations can be looked up by ID, or by address.
///
/// \b Options:
/// This includes:
/// \b Enabled/Disabled
/// \b Ignore Count
/// \b Callback
/// \b Condition
/// Note, these options can be set on the breakpoint, and they can also be set
/// on the
/// individual locations. The options set on the breakpoint take precedence
/// over the
/// options set on the individual location.
/// So for instance disabling the breakpoint will cause NONE of the locations to
/// get hit.
/// But if the breakpoint is enabled, then the location's enabled state will be
/// checked
/// to determine whether to insert that breakpoint location.
/// Similarly, if the breakpoint condition says "stop", we won't check the
/// location's condition.
/// But if the breakpoint condition says "continue", then we will check the
/// location for whether
/// to actually stop or not.
/// One subtle point worth observing here is that you don't actually stop at a
/// Breakpoint, you
/// always stop at one of its locations. So the "should stop" tests are done by
/// the location,
/// not by the breakpoint.
//----------------------------------------------------------------------
class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
public Stoppoint {
public:
static const ConstString &GetEventIdentifier();
//------------------------------------------------------------------
/// An enum specifying the match style for breakpoint settings. At
/// present only used for function name style breakpoints.
//------------------------------------------------------------------
typedef enum { Exact, Regexp, Glob } MatchType;
private:
enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName };
static const char
*g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)];
static const char *GetKey(OptionNames enum_value) {
return g_option_names[static_cast<uint32_t>(enum_value)];
}
public:
class BreakpointEventData : public EventData {
public:
BreakpointEventData(lldb::BreakpointEventType sub_type,
const lldb::BreakpointSP &new_breakpoint_sp);
~BreakpointEventData() override;
static const ConstString &GetFlavorString();
const ConstString &GetFlavor() const override;
lldb::BreakpointEventType GetBreakpointEventType() const;
lldb::BreakpointSP &GetBreakpoint();
BreakpointLocationCollection &GetBreakpointLocationCollection() {
return m_locations;
}
void Dump(Stream *s) const override;
static lldb::BreakpointEventType
GetBreakpointEventTypeFromEvent(const lldb::EventSP &event_sp);
static lldb::BreakpointSP
GetBreakpointFromEvent(const lldb::EventSP &event_sp);
static lldb::BreakpointLocationSP
GetBreakpointLocationAtIndexFromEvent(const lldb::EventSP &event_sp,
uint32_t loc_idx);
static size_t
GetNumBreakpointLocationsFromEvent(const lldb::EventSP &event_sp);
static const BreakpointEventData *
GetEventDataFromEvent(const Event *event_sp);
private:
lldb::BreakpointEventType m_breakpoint_event;
lldb::BreakpointSP m_new_breakpoint_sp;
BreakpointLocationCollection m_locations;
DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
};
class BreakpointPrecondition {
public:
virtual ~BreakpointPrecondition() = default;
virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
virtual Error ConfigurePrecondition(Args &options);
virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
};
typedef std::shared_ptr<BreakpointPrecondition> BreakpointPreconditionSP;
// Saving & restoring breakpoints:
static lldb::BreakpointSP CreateFromStructuredData(
Target &target, StructuredData::ObjectSP &data_object_sp, Error &error);
static bool
SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp,
std::vector<std::string> &names);
virtual StructuredData::ObjectSP SerializeToStructuredData();
static const char *GetSerializationKey() { return "Breakpoint"; }
//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is not virtual since there should be no reason to subclass
/// breakpoints. The varieties of breakpoints are specified instead by
/// providing different resolvers & filters.
//------------------------------------------------------------------
~Breakpoint() override;
//------------------------------------------------------------------
// Methods
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Tell whether this breakpoint is an "internal" breakpoint.
/// @return
/// Returns \b true if this is an internal breakpoint, \b false otherwise.
//------------------------------------------------------------------
bool IsInternal() const;
//------------------------------------------------------------------
/// Standard "Dump" method. At present it does nothing.
//------------------------------------------------------------------
void Dump(Stream *s) override;
//------------------------------------------------------------------
// The next set of methods provide ways to tell the breakpoint to update
// it's location list - usually done when modules appear or disappear.
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Tell this breakpoint to clear all its breakpoint sites. Done
/// when the process holding the breakpoint sites is destroyed.
//------------------------------------------------------------------
void ClearAllBreakpointSites();
//------------------------------------------------------------------
/// Tell this breakpoint to scan it's target's module list and resolve any
/// new locations that match the breakpoint's specifications.
//------------------------------------------------------------------
void ResolveBreakpoint();
//------------------------------------------------------------------
/// Tell this breakpoint to scan a given module list and resolve any
/// new locations that match the breakpoint's specifications.
///
/// @param[in] module_list
/// The list of modules to look in for new locations.
///
/// @param[in] send_event
/// If \b true, send a breakpoint location added event for non-internal
/// breakpoints.
//------------------------------------------------------------------
void ResolveBreakpointInModules(ModuleList &module_list,
bool send_event = true);
//------------------------------------------------------------------
/// Tell this breakpoint to scan a given module list and resolve any
/// new locations that match the breakpoint's specifications.
///
/// @param[in] changed_modules
/// The list of modules to look in for new locations.
///
/// @param[in] new_locations
/// Fills new_locations with the new locations that were made.
//------------------------------------------------------------------
void ResolveBreakpointInModules(ModuleList &module_list,
BreakpointLocationCollection &new_locations);
//------------------------------------------------------------------
/// Like ResolveBreakpointInModules, but allows for "unload" events, in
/// which case we will remove any locations that are in modules that got
/// unloaded.
///
/// @param[in] changedModules
/// The list of modules to look in for new locations.
/// @param[in] load_event
/// If \b true then the modules were loaded, if \b false, unloaded.
/// @param[in] delete_locations
/// If \b true then the modules were unloaded delete any locations in the
/// changed modules.
//------------------------------------------------------------------
void ModulesChanged(ModuleList &changed_modules, bool load_event,
bool delete_locations = false);
//------------------------------------------------------------------
/// Tells the breakpoint the old module \a old_module_sp has been
/// replaced by new_module_sp (usually because the underlying file has been
/// rebuilt, and the old version is gone.)
///
/// @param[in] old_module_sp
/// The old module that is going away.
/// @param[in] new_module_sp
/// The new module that is replacing it.
//------------------------------------------------------------------
void ModuleReplaced(lldb::ModuleSP old_module_sp,
lldb::ModuleSP new_module_sp);
//------------------------------------------------------------------
// The next set of methods provide access to the breakpoint locations
// for this breakpoint.
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Add a location to the breakpoint's location list. This is only meant
/// to be called by the breakpoint's resolver. FIXME: how do I ensure that?
///
/// @param[in] addr
/// The Address specifying the new location.
/// @param[out] new_location
/// Set to \b true if a new location was created, to \b false if there
/// already was a location at this Address.
/// @return
/// Returns a pointer to the new location.
//------------------------------------------------------------------
lldb::BreakpointLocationSP AddLocation(const Address &addr,
bool *new_location = nullptr);
//------------------------------------------------------------------
/// Find a breakpoint location by Address.
///
/// @param[in] addr
/// The Address specifying the location.
/// @return
/// Returns a shared pointer to the location at \a addr. The pointer
/// in the shared pointer will be nullptr if there is no location at that
/// address.
//------------------------------------------------------------------
lldb::BreakpointLocationSP FindLocationByAddress(const Address &addr);
//------------------------------------------------------------------
/// Find a breakpoint location ID by Address.
///
/// @param[in] addr
/// The Address specifying the location.
/// @return
/// Returns the UID of the location at \a addr, or \b LLDB_INVALID_ID if
/// there is no breakpoint location at that address.
//------------------------------------------------------------------
lldb::break_id_t FindLocationIDByAddress(const Address &addr);
//------------------------------------------------------------------
/// Find a breakpoint location for a given breakpoint location ID.
///
/// @param[in] bp_loc_id
/// The ID specifying the location.
/// @return
/// Returns a shared pointer to the location with ID \a bp_loc_id. The
/// pointer
/// in the shared pointer will be nullptr if there is no location with that
/// ID.
//------------------------------------------------------------------
lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id);
//------------------------------------------------------------------
/// Get breakpoint locations by index.
///
/// @param[in] index
/// The location index.
///
/// @return
/// Returns a shared pointer to the location with index \a
/// index. The shared pointer might contain nullptr if \a index is
/// greater than then number of actual locations.
//------------------------------------------------------------------
lldb::BreakpointLocationSP GetLocationAtIndex(size_t index);
//------------------------------------------------------------------
/// Removes all invalid breakpoint locations.
///
/// Removes all breakpoint locations with architectures that aren't
/// compatible with \a arch. Also remove any breakpoint locations
/// with whose locations have address where the section has been
/// deleted (module and object files no longer exist).
///
/// This is typically used after the process calls exec, or anytime
/// the architecture of the target changes.
///
/// @param[in] arch
/// If valid, check the module in each breakpoint to make sure
/// they are compatible, otherwise, ignore architecture.
//------------------------------------------------------------------
void RemoveInvalidLocations(const ArchSpec &arch);
//------------------------------------------------------------------
// The next section deals with various breakpoint options.
//------------------------------------------------------------------
//------------------------------------------------------------------
/// If \a enable is \b true, enable the breakpoint, if \b false disable it.
//------------------------------------------------------------------
void SetEnabled(bool enable) override;
//------------------------------------------------------------------
/// Check the Enable/Disable state.
/// @return
/// \b true if the breakpoint is enabled, \b false if disabled.
//------------------------------------------------------------------
bool IsEnabled() override;
//------------------------------------------------------------------
/// Set the breakpoint to ignore the next \a count breakpoint hits.
/// @param[in] count
/// The number of breakpoint hits to ignore.
//------------------------------------------------------------------
void SetIgnoreCount(uint32_t count);
//------------------------------------------------------------------
/// Return the current ignore count/
/// @return
/// The number of breakpoint hits to be ignored.
//------------------------------------------------------------------
uint32_t GetIgnoreCount() const;
//------------------------------------------------------------------
/// Return the current hit count for all locations.
/// @return
/// The current hit count for all locations.
//------------------------------------------------------------------
uint32_t GetHitCount() const;
//------------------------------------------------------------------
/// If \a one_shot is \b true, breakpoint will be deleted on first hit.
//------------------------------------------------------------------
void SetOneShot(bool one_shot);
//------------------------------------------------------------------
/// Check the OneShot state.
/// @return
/// \b true if the breakpoint is one shot, \b false otherwise.
//------------------------------------------------------------------
bool IsOneShot() const;
//------------------------------------------------------------------
/// Set the valid thread to be checked when the breakpoint is hit.
/// @param[in] thread_id
/// If this thread hits the breakpoint, we stop, otherwise not.
//------------------------------------------------------------------
void SetThreadID(lldb::tid_t thread_id);
//------------------------------------------------------------------
/// Return the current stop thread value.
/// @return
/// The thread id for which the breakpoint hit will stop,
/// LLDB_INVALID_THREAD_ID for all threads.
//------------------------------------------------------------------
lldb::tid_t GetThreadID() const;
void SetThreadIndex(uint32_t index);
uint32_t GetThreadIndex() const;
void SetThreadName(const char *thread_name);
const char *GetThreadName() const;
void SetQueueName(const char *queue_name);
const char *GetQueueName() const;
//------------------------------------------------------------------
/// Set the callback action invoked when the breakpoint is hit.
///
/// @param[in] callback
/// The method that will get called when the breakpoint is hit.
/// @param[in] baton
/// A void * pointer that will get passed back to the callback function.
/// @param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
/// handled on the public event thread after the stop has been posted.
///
/// @return
/// \b true if the process should stop when you hit the breakpoint.
/// \b false if it should continue.
//------------------------------------------------------------------
void SetCallback(BreakpointHitCallback callback, void *baton,
bool is_synchronous = false);
void SetCallback(BreakpointHitCallback callback,
const lldb::BatonSP &callback_baton_sp,
bool is_synchronous = false);
void ClearCallback();
//------------------------------------------------------------------
/// Set the breakpoint's condition.
///
/// @param[in] condition
/// The condition expression to evaluate when the breakpoint is hit.
/// Pass in nullptr to clear the condition.
//------------------------------------------------------------------
void SetCondition(const char *condition);
//------------------------------------------------------------------
/// Return a pointer to the text of the condition expression.
///
/// @return
/// A pointer to the condition expression text, or nullptr if no
// condition has been set.
//------------------------------------------------------------------
const char *GetConditionText() const;
//------------------------------------------------------------------
// The next section are various utility functions.
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Return the number of breakpoint locations that have resolved to
/// actual breakpoint sites.
///
/// @return
/// The number locations resolved breakpoint sites.
//------------------------------------------------------------------
size_t GetNumResolvedLocations() const;
//------------------------------------------------------------------
/// Return the number of breakpoint locations.
///
/// @return
/// The number breakpoint locations.
//------------------------------------------------------------------
size_t GetNumLocations() const;
//------------------------------------------------------------------
/// Put a description of this breakpoint into the stream \a s.
///
/// @param[in] s
/// Stream into which to dump the description.
///
/// @param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level,
bool show_locations = false);
//------------------------------------------------------------------
/// Set the "kind" description for a breakpoint. If the breakpoint is hit
/// the stop info will show this "kind" description instead of the breakpoint
/// number. Mostly useful for internal breakpoints, where the breakpoint
/// number
/// doesn't have meaning to the user.
///
/// @param[in] kind
/// New "kind" description.
//------------------------------------------------------------------
void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); }
//------------------------------------------------------------------
/// Return the "kind" description for a breakpoint.
///
/// @return
/// The breakpoint kind, or nullptr if none is set.
//------------------------------------------------------------------
const char *GetBreakpointKind() const { return m_kind_description.c_str(); }
//------------------------------------------------------------------
/// Accessor for the breakpoint Target.
/// @return
/// This breakpoint's Target.
//------------------------------------------------------------------
Target &GetTarget() { return m_target; }
const Target &GetTarget() const { return m_target; }
const lldb::TargetSP GetTargetSP();
void GetResolverDescription(Stream *s);
//------------------------------------------------------------------
/// Find breakpoint locations which match the (filename, line_number)
/// description.
/// The breakpoint location collection is to be filled with the matching
/// locations.
/// It should be initialized with 0 size by the API client.
///
/// @return
/// True if there is a match
///
/// The locations which match the filename and line_number in loc_coll.
/// If its
/// size is 0 and true is returned, it means the breakpoint fully matches
/// the
/// description.
//------------------------------------------------------------------
bool GetMatchingFileLine(const ConstString &filename, uint32_t line_number,
BreakpointLocationCollection &loc_coll);
void GetFilterDescription(Stream *s);
//------------------------------------------------------------------
/// Returns the BreakpointOptions structure set at the breakpoint level.
///
/// Meant to be used by the BreakpointLocation class.
///
/// @return
/// A pointer to this breakpoint's BreakpointOptions.
//------------------------------------------------------------------
BreakpointOptions *GetOptions();
//------------------------------------------------------------------
/// Invoke the callback action when the breakpoint is hit.
///
/// Meant to be used by the BreakpointLocation class.
///
/// @param[in] context
/// Described the breakpoint event.
///
/// @param[in] bp_loc_id
/// Which breakpoint location hit this breakpoint.
///
/// @return
/// \b true if the target should stop at this breakpoint and \b false not.
//------------------------------------------------------------------
bool InvokeCallback(StoppointCallbackContext *context,
lldb::break_id_t bp_loc_id);
bool IsHardware() const { return m_hardware; }
lldb::BreakpointResolverSP GetResolver() { return m_resolver_sp; }
lldb::SearchFilterSP GetSearchFilter() { return m_filter_sp; }
bool AddName(const char *new_name, Error &error);
void RemoveName(const char *name_to_remove) {
if (name_to_remove)
m_name_list.erase(name_to_remove);
}
bool MatchesName(const char *name) {
return m_name_list.find(name) != m_name_list.end();
}
void GetNames(std::vector<std::string> &names) {
names.clear();
for (auto name : m_name_list) {
names.push_back(name);
}
}
//------------------------------------------------------------------
/// Set a pre-condition filter that overrides all user provided
/// filters/callbacks etc.
///
/// Used to define fancy breakpoints that can do dynamic hit detection without
/// taking up the condition slot -
/// which really belongs to the user anyway...
///
/// The Precondition should not continue the target, it should return true if
/// the condition says to stop and
/// false otherwise.
///
//------------------------------------------------------------------
void SetPrecondition(BreakpointPreconditionSP precondition_sp) {
m_precondition_sp = precondition_sp;
}
bool EvaluatePrecondition(StoppointCallbackContext &context);
BreakpointPreconditionSP GetPrecondition() { return m_precondition_sp; }
protected:
friend class Target;
//------------------------------------------------------------------
// Protected Methods
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Constructors and Destructors
/// Only the Target can make a breakpoint, and it owns the breakpoint
/// lifespans.
/// The constructor takes a filter and a resolver. Up in Target there are
/// convenience
/// variants that make breakpoints for some common cases.
///
/// @param[in] target
/// The target in which the breakpoint will be set.
///
/// @param[in] filter_sp
/// Shared pointer to the search filter that restricts the search domain of
/// the breakpoint.
///
/// @param[in] resolver_sp
/// Shared pointer to the resolver object that will determine breakpoint
/// matches.
///
/// @param hardware
/// If true, request a hardware breakpoint to be used to implement the
/// breakpoint locations.
///
/// @param resolve_indirect_symbols
/// If true, and the address of a given breakpoint location in this
/// breakpoint is set on an
/// indirect symbol (i.e. Symbol::IsIndirect returns true) then the actual
/// breakpoint site will
/// be set on the target of the indirect symbol.
//------------------------------------------------------------------
// This is the generic constructor
Breakpoint(Target &target, lldb::SearchFilterSP &filter_sp,
lldb::BreakpointResolverSP &resolver_sp, bool hardware,
bool resolve_indirect_symbols = true);
friend class BreakpointLocation; // To call the following two when determining
// whether to stop.
void DecrementIgnoreCount();
// BreakpointLocation::IgnoreCountShouldStop &
// Breakpoint::IgnoreCountShouldStop can only be called once per stop,
// and BreakpointLocation::IgnoreCountShouldStop should be tested first, and
// if it returns false we should
// continue, otherwise we should test Breakpoint::IgnoreCountShouldStop.
bool IgnoreCountShouldStop();
void IncrementHitCount() { m_hit_count++; }
void DecrementHitCount() {
assert(m_hit_count > 0);
m_hit_count--;
}
private:
// This one should only be used by Target to copy breakpoints from target to
// target - primarily from the dummy
// target to prime new targets.
Breakpoint(Target &new_target, Breakpoint &bp_to_copy_from);
//------------------------------------------------------------------
// For Breakpoint only
//------------------------------------------------------------------
bool m_being_created;
bool
m_hardware; // If this breakpoint is required to use a hardware breakpoint
Target &m_target; // The target that holds this breakpoint.
std::unordered_set<std::string> m_name_list; // If not empty, this is the name
// of this breakpoint (many
// breakpoints can share the same
// name.)
lldb::SearchFilterSP
m_filter_sp; // The filter that constrains the breakpoint's domain.
lldb::BreakpointResolverSP
m_resolver_sp; // The resolver that defines this breakpoint.
BreakpointPreconditionSP m_precondition_sp; // The precondition is a
// breakpoint-level hit filter
// that can be used
// to skip certain breakpoint hits. For instance, exception breakpoints
// use this to limit the stop to certain exception classes, while leaving
// the condition & callback free for user specification.
std::unique_ptr<BreakpointOptions>
m_options_up; // Settable breakpoint options
BreakpointLocationList
m_locations; // The list of locations currently found for this breakpoint.
std::string m_kind_description;
bool m_resolve_indirect_symbols;
uint32_t m_hit_count; // Number of times this breakpoint/watchpoint has been
// hit. This is kept
// separately from the locations hit counts, since locations can go away when
// their backing library gets unloaded, and we would lose hit counts.
void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
void SendBreakpointChangedEvent(BreakpointEventData *data);
DISALLOW_COPY_AND_ASSIGN(Breakpoint);
};
} // namespace lldb_private
#endif // liblldb_Breakpoint_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Core/StreamFile.h
|
//===-- StreamFile.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_StreamFile_h_
#define liblldb_StreamFile_h_
// C Includes
// C++ Includes
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/File.h"
namespace lldb_private {
class StreamFile : public Stream {
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
StreamFile();
StreamFile(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
StreamFile(int fd, bool transfer_ownership);
StreamFile(const char *path);
StreamFile(const char *path, uint32_t options,
uint32_t permissions = lldb::eFilePermissionsFileDefault);
StreamFile(FILE *fh, bool transfer_ownership);
~StreamFile() override;
File &GetFile() { return m_file; }
const File &GetFile() const { return m_file; }
void Flush() override;
size_t Write(const void *s, size_t length) override;
protected:
//------------------------------------------------------------------
// Classes that inherit from StreamFile can see and modify these
//------------------------------------------------------------------
File m_file;
private:
DISALLOW_COPY_AND_ASSIGN(StreamFile);
};
} // namespace lldb_private
#endif // liblldb_StreamFile_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/unittests/gtest_common.h
|
<reponame>Polidea/SiriusObfuscator
//===-- gtest_common.h ------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#if defined(LLDB_GTEST_COMMON_H)
#error "gtest_common.h should not be included manually."
#else
#define LLDB_GTEST_COMMON_H
#endif
// This header file is force included by all of LLDB's unittest compilation
// units. Be very leary about putting anything in this file.
#if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
// Due to a bug in <thread>, when _HAS_EXCEPTIONS == 0 the header will try to
// call
// uncaught_exception() without having a declaration for it. The fix for this
// is
// to manually #include <eh.h>, which contains this declaration.
#include <eh.h>
#endif
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Target/ThreadList.h
|
//===-- ThreadList.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ThreadList_h_
#define liblldb_ThreadList_h_
#include <mutex>
#include <vector>
#include "lldb/Core/UserID.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadCollection.h"
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
// This is a thread list with lots of functionality for use only by the process
// for which this is the thread list. A generic container class with iterator
// functionality is ThreadCollection.
class ThreadList : public ThreadCollection {
friend class Process;
public:
ThreadList(Process *process);
ThreadList(const ThreadList &rhs);
~ThreadList() override;
const ThreadList &operator=(const ThreadList &rhs);
uint32_t GetSize(bool can_update = true);
// Return the selected thread if there is one. Otherwise, return the thread
// selected at index 0.
lldb::ThreadSP GetSelectedThread();
// Manage the thread to use for running expressions. This is usually the
// Selected thread,
// but sometimes (e.g. when evaluating breakpoint conditions & stop hooks) it
// isn't.
class ExpressionExecutionThreadPusher {
public:
ExpressionExecutionThreadPusher(ThreadList &thread_list, lldb::tid_t tid)
: m_thread_list(&thread_list), m_tid(tid) {
m_thread_list->PushExpressionExecutionThread(m_tid);
}
ExpressionExecutionThreadPusher(lldb::ThreadSP thread_sp);
~ExpressionExecutionThreadPusher() {
if (m_thread_list && m_tid != LLDB_INVALID_THREAD_ID)
m_thread_list->PopExpressionExecutionThread(m_tid);
}
private:
ThreadList *m_thread_list;
lldb::tid_t m_tid;
};
lldb::ThreadSP GetExpressionExecutionThread();
protected:
void PushExpressionExecutionThread(lldb::tid_t tid);
void PopExpressionExecutionThread(lldb::tid_t tid);
public:
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify = false);
bool SetSelectedThreadByIndexID(uint32_t index_id, bool notify = false);
void Clear();
void Flush();
void Destroy();
// Note that "idx" is not the same as the "thread_index". It is a zero
// based index to accessing the current threads, whereas "thread_index"
// is a unique index assigned
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update = true);
lldb::ThreadSP FindThreadByID(lldb::tid_t tid, bool can_update = true);
lldb::ThreadSP FindThreadByProtocolID(lldb::tid_t tid,
bool can_update = true);
lldb::ThreadSP RemoveThreadByID(lldb::tid_t tid, bool can_update = true);
lldb::ThreadSP RemoveThreadByProtocolID(lldb::tid_t tid,
bool can_update = true);
lldb::ThreadSP FindThreadByIndexID(uint32_t index_id, bool can_update = true);
lldb::ThreadSP GetThreadSPForThreadPtr(Thread *thread_ptr);
bool ShouldStop(Event *event_ptr);
Vote ShouldReportStop(Event *event_ptr);
Vote ShouldReportRun(Event *event_ptr);
void RefreshStateAfterStop();
//------------------------------------------------------------------
/// The thread list asks tells all the threads it is about to resume.
/// If a thread can "resume" without having to resume the target, it
/// will return false for WillResume, and then the process will not be
/// restarted.
///
/// @return
/// \b true instructs the process to resume normally,
/// \b false means start & stopped events will be generated, but
/// the process will not actually run. The thread must then return
/// the correct StopInfo when asked.
///
//------------------------------------------------------------------
bool WillResume();
void DidResume();
void DidStop();
void DiscardThreadPlans();
uint32_t GetStopID() const;
void SetStopID(uint32_t stop_id);
std::recursive_mutex &GetMutex() const override;
void Update(ThreadList &rhs);
protected:
void SetShouldReportStop(Vote vote);
void NotifySelectedThreadChanged(lldb::tid_t tid);
//------------------------------------------------------------------
// Classes that inherit from Process can see and modify these
//------------------------------------------------------------------
Process *m_process; ///< The process that manages this thread list.
uint32_t
m_stop_id; ///< The process stop ID that this thread list is valid for.
lldb::tid_t
m_selected_tid; ///< For targets that need the notion of a current thread.
std::vector<lldb::tid_t> m_expression_tid_stack;
private:
ThreadList();
};
} // namespace lldb_private
#endif // liblldb_ThreadList_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/clang/test/CodeGen/ppc64-complex-parms.c
|
// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
float crealf(_Complex float);
double creal(_Complex double);
long double creall(_Complex long double);
float foo_float(_Complex float x) {
return crealf(x);
}
// CHECK: define float @foo_float(float {{[%A-Za-z0-9.]+}}, float {{[%A-Za-z0-9.]+}}) [[NUW:#[0-9]+]] {
double foo_double(_Complex double x) {
return creal(x);
}
// CHECK: define double @foo_double(double {{[%A-Za-z0-9.]+}}, double {{[%A-Za-z0-9.]+}}) [[NUW]] {
long double foo_long_double(_Complex long double x) {
return creall(x);
}
// CHECK: define ppc_fp128 @foo_long_double(ppc_fp128 {{[%A-Za-z0-9.]+}}, ppc_fp128 {{[%A-Za-z0-9.]+}}) [[NUW]] {
int foo_int(_Complex int x) {
return __real__ x;
}
// CHECK: define signext i32 @foo_int(i32 {{[%A-Za-z0-9.]+}}, i32 {{[%A-Za-z0-9.]+}}) [[NUW]] {
short foo_short(_Complex short x) {
return __real__ x;
}
// CHECK: define signext i16 @foo_short(i16 {{[%A-Za-z0-9.]+}}, i16 {{[%A-Za-z0-9.]+}}) [[NUW]] {
signed char foo_char(_Complex signed char x) {
return __real__ x;
}
// CHECK: define signext i8 @foo_char(i8 {{[%A-Za-z0-9.]+}}, i8 {{[%A-Za-z0-9.]+}}) [[NUW]] {
long foo_long(_Complex long x) {
return __real__ x;
}
// CHECK: define i64 @foo_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
long long foo_long_long(_Complex long long x) {
return __real__ x;
}
// CHECK: define i64 @foo_long_long(i64 {{[%A-Za-z0-9.]+}}, i64 {{[%A-Za-z0-9.]+}}) [[NUW]] {
void bar_float(void) {
foo_float(2.0f - 2.5fi);
}
// CHECK: define void @bar_float() [[NUW]] {
// CHECK: %[[VAR1:[A-Za-z0-9.]+]] = alloca { float, float }, align 4
// CHECK: %[[VAR2:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }, { float, float }* %[[VAR1]], i32 0, i32 0
// CHECK: %[[VAR3:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }, { float, float }* %[[VAR1]], i32 0, i32 1
// CHECK: store float 2.000000e+00, float* %[[VAR2]]
// CHECK: store float -2.500000e+00, float* %[[VAR3]]
// CHECK: %[[VAR4:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }, { float, float }* %[[VAR1]], i32 0, i32 0
// CHECK: %[[VAR5:[A-Za-z0-9.]+]] = load float, float* %[[VAR4]], align 4
// CHECK: %[[VAR6:[A-Za-z0-9.]+]] = getelementptr inbounds { float, float }, { float, float }* %[[VAR1]], i32 0, i32 1
// CHECK: %[[VAR7:[A-Za-z0-9.]+]] = load float, float* %[[VAR6]], align 4
// CHECK: %{{[A-Za-z0-9.]+}} = call float @foo_float(float %[[VAR5]], float %[[VAR7]])
void bar_double(void) {
foo_double(2.0 - 2.5i);
}
// CHECK: define void @bar_double() [[NUW]] {
// CHECK: %[[VAR11:[A-Za-z0-9.]+]] = alloca { double, double }, align 8
// CHECK: %[[VAR12:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }, { double, double }* %[[VAR11]], i32 0, i32 0
// CHECK: %[[VAR13:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }, { double, double }* %[[VAR11]], i32 0, i32 1
// CHECK: store double 2.000000e+00, double* %[[VAR12]]
// CHECK: store double -2.500000e+00, double* %[[VAR13]]
// CHECK: %[[VAR14:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }, { double, double }* %[[VAR11]], i32 0, i32 0
// CHECK: %[[VAR15:[A-Za-z0-9.]+]] = load double, double* %[[VAR14]], align 8
// CHECK: %[[VAR16:[A-Za-z0-9.]+]] = getelementptr inbounds { double, double }, { double, double }* %[[VAR11]], i32 0, i32 1
// CHECK: %[[VAR17:[A-Za-z0-9.]+]] = load double, double* %[[VAR16]], align 8
// CHECK: %{{[A-Za-z0-9.]+}} = call double @foo_double(double %[[VAR15]], double %[[VAR17]])
void bar_long_double(void) {
foo_long_double(2.0L - 2.5Li);
}
// CHECK: define void @bar_long_double() [[NUW]] {
// CHECK: %[[VAR21:[A-Za-z0-9.]+]] = alloca { ppc_fp128, ppc_fp128 }, align 16
// CHECK: %[[VAR22:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
// CHECK: %[[VAR23:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
// CHECK: store ppc_fp128 0xM40000000000000000000000000000000, ppc_fp128* %[[VAR22]]
// CHECK: store ppc_fp128 0xMC0040000000000000000000000000000, ppc_fp128* %[[VAR23]]
// CHECK: %[[VAR24:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
// CHECK: %[[VAR25:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR24]], align 16
// CHECK: %[[VAR26:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
// CHECK: %[[VAR27:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR26]], align 16
// CHECK: %{{[A-Za-z0-9.]+}} = call ppc_fp128 @foo_long_double(ppc_fp128 %[[VAR25]], ppc_fp128 %[[VAR27]])
void bar_int(void) {
foo_int(2 - 3i);
}
// CHECK: define void @bar_int() [[NUW]] {
// CHECK: %[[VAR31:[A-Za-z0-9.]+]] = alloca { i32, i32 }, align 4
// CHECK: %[[VAR32:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 0
// CHECK: %[[VAR33:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 1
// CHECK: store i32 2, i32* %[[VAR32]]
// CHECK: store i32 -3, i32* %[[VAR33]]
// CHECK: %[[VAR34:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 0
// CHECK: %[[VAR35:[A-Za-z0-9.]+]] = load i32, i32* %[[VAR34]], align 4
// CHECK: %[[VAR36:[A-Za-z0-9.]+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* %[[VAR31]], i32 0, i32 1
// CHECK: %[[VAR37:[A-Za-z0-9.]+]] = load i32, i32* %[[VAR36]], align 4
// CHECK: %{{[A-Za-z0-9.]+}} = call signext i32 @foo_int(i32 %[[VAR35]], i32 %[[VAR37]])
void bar_short(void) {
foo_short(2 - 3i);
}
// CHECK: define void @bar_short() [[NUW]] {
// CHECK: %[[VAR41:[A-Za-z0-9.]+]] = alloca { i16, i16 }, align 2
// CHECK: %[[VAR42:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }, { i16, i16 }* %[[VAR41]], i32 0, i32 0
// CHECK: %[[VAR43:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }, { i16, i16 }* %[[VAR41]], i32 0, i32 1
// CHECK: store i16 2, i16* %[[VAR42]]
// CHECK: store i16 -3, i16* %[[VAR43]]
// CHECK: %[[VAR44:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }, { i16, i16 }* %[[VAR41]], i32 0, i32 0
// CHECK: %[[VAR45:[A-Za-z0-9.]+]] = load i16, i16* %[[VAR44]], align 2
// CHECK: %[[VAR46:[A-Za-z0-9.]+]] = getelementptr inbounds { i16, i16 }, { i16, i16 }* %[[VAR41]], i32 0, i32 1
// CHECK: %[[VAR47:[A-Za-z0-9.]+]] = load i16, i16* %[[VAR46]], align 2
// CHECK: %{{[A-Za-z0-9.]+}} = call signext i16 @foo_short(i16 %[[VAR45]], i16 %[[VAR47]])
void bar_char(void) {
foo_char(2 - 3i);
}
// CHECK: define void @bar_char() [[NUW]] {
// CHECK: %[[VAR51:[A-Za-z0-9.]+]] = alloca { i8, i8 }, align 1
// CHECK: %[[VAR52:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %[[VAR51]], i32 0, i32 0
// CHECK: %[[VAR53:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %[[VAR51]], i32 0, i32 1
// CHECK: store i8 2, i8* %[[VAR52]]
// CHECK: store i8 -3, i8* %[[VAR53]]
// CHECK: %[[VAR54:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %[[VAR51]], i32 0, i32 0
// CHECK: %[[VAR55:[A-Za-z0-9.]+]] = load i8, i8* %[[VAR54]], align 1
// CHECK: %[[VAR56:[A-Za-z0-9.]+]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %[[VAR51]], i32 0, i32 1
// CHECK: %[[VAR57:[A-Za-z0-9.]+]] = load i8, i8* %[[VAR56]], align 1
// CHECK: %{{[A-Za-z0-9.]+}} = call signext i8 @foo_char(i8 %[[VAR55]], i8 %[[VAR57]])
void bar_long(void) {
foo_long(2L - 3Li);
}
// CHECK: define void @bar_long() [[NUW]] {
// CHECK: %[[VAR61:[A-Za-z0-9.]+]] = alloca { i64, i64 }, align 8
// CHECK: %[[VAR62:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR61]], i32 0, i32 0
// CHECK: %[[VAR63:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR61]], i32 0, i32 1
// CHECK: store i64 2, i64* %[[VAR62]]
// CHECK: store i64 -3, i64* %[[VAR63]]
// CHECK: %[[VAR64:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR61]], i32 0, i32 0
// CHECK: %[[VAR65:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR64]], align 8
// CHECK: %[[VAR66:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR61]], i32 0, i32 1
// CHECK: %[[VAR67:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR66]], align 8
// CHECK: %{{[A-Za-z0-9.]+}} = call i64 @foo_long(i64 %[[VAR65]], i64 %[[VAR67]])
void bar_long_long(void) {
foo_long_long(2LL - 3LLi);
}
// CHECK: define void @bar_long_long() [[NUW]] {
// CHECK: %[[VAR71:[A-Za-z0-9.]+]] = alloca { i64, i64 }, align 8
// CHECK: %[[VAR72:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 0
// CHECK: %[[VAR73:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 1
// CHECK: store i64 2, i64* %[[VAR72]]
// CHECK: store i64 -3, i64* %[[VAR73]]
// CHECK: %[[VAR74:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 0
// CHECK: %[[VAR75:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR74]], align 8
// CHECK: %[[VAR76:[A-Za-z0-9.]+]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[VAR71]], i32 0, i32 1
// CHECK: %[[VAR77:[A-Za-z0-9.]+]] = load i64, i64* %[[VAR76]], align 8
// CHECK: %{{[A-Za-z0-9.]+}} = call i64 @foo_long_long(i64 %[[VAR75]], i64 %[[VAR77]])
// CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} }
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/tools/lldb-mi/MIUtilThreadBaseStd.h
|
//===-- MIUtilThreadBaseStd.h -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#pragma once
// Third party headers:
#ifdef _MSC_VER
#include <eh.h>
#endif // _MSC_VER
#include <mutex>
#include <thread>
// In-house headers:
#include "MIDataTypes.h"
#include "MIUtilString.h"
//++
//============================================================================
// Details: MI common code utility class. Handle thread mutual exclusion.
// Embed Mutexes in your Active Object and then use them through Locks.
//--
class CMIUtilThreadMutex {
// Methods:
public:
/* ctor */ CMIUtilThreadMutex() {}
//
void Lock(); // Wait until mutex can be obtained
void Unlock(); // Release the mutex
bool TryLock(); // Gain the lock if available
// Overrideable:
public:
// From CMICmnBase
/* dtor */ virtual ~CMIUtilThreadMutex() {}
// Attributes:
private:
std::recursive_mutex m_mutex;
};
//++
//============================================================================
// Details: MI common code utility class. Thread object.
//--
class CMIUtilThread {
// Typedef:
public:
typedef MIuint (*FnThreadProc)(void *vpThisClass);
// Methods:
public:
/* ctor */ CMIUtilThread();
//
bool Start(FnThreadProc vpFn, void *vpArg); // Start execution of this thread
bool Join(); // Wait for this thread to stop
bool IsActive(); // Returns true if this thread is running
void Finish(); // Finish this thread
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThread();
// Methods:
private:
CMIUtilThreadMutex m_mutex;
std::thread *m_pThread;
bool m_bIsActive;
};
//++
//============================================================================
// Details: MI common code utility class. Base class for a worker thread active
// object. Runs an 'captive thread'.
//--
class CMIUtilThreadActiveObjBase {
// Methods:
public:
/* ctor */ CMIUtilThreadActiveObjBase();
//
bool Acquire(); // Obtain a reference to this object
bool Release(); // Release a reference to this object
bool ThreadIsActive(); // Return true if this object is running
bool ThreadJoin(); // Wait for this thread to stop running
bool ThreadKill(); // Force this thread to stop, regardless of references
bool ThreadExecute(); // Start this objects execution in another thread
void ThreadManage();
// Overrideable:
public:
/* dtor */ virtual ~CMIUtilThreadActiveObjBase();
//
// Each thread object must supple a unique name that can be used to locate it
virtual const CMIUtilString &ThreadGetName() const = 0;
// Statics:
protected:
static MIuint ThreadEntry(void *vpThisClass); // Thread entry point
// Overrideable:
protected:
virtual bool ThreadRun(bool &vrIsAlive) = 0; // Call the main worker method
virtual bool ThreadFinish() = 0; // Finish of what you were doing
// Attributes:
protected:
volatile MIuint m_references; // Stores the current lifetime state of this
// thread, 0 = running, > 0 = shutting down
volatile bool
m_bHasBeenKilled; // Set to true when this thread has been killed
CMIUtilThread m_thread; // The execution thread
CMIUtilThreadMutex m_mutex; // This mutex allows us to safely communicate with
// this thread object across the interface from
// multiple threads
};
//++
//============================================================================
// Details: MI common code utility class. Handle thread resource locking.
// Put Locks inside all the methods of your Active Object that access
// data shared with the captive thread.
//--
class CMIUtilThreadLock {
// Methods:
public:
/* ctor */
CMIUtilThreadLock(CMIUtilThreadMutex &vMutex) : m_rMutex(vMutex) {
m_rMutex.Lock();
}
// Overrideable:
public:
/* dtor */
virtual ~CMIUtilThreadLock() { m_rMutex.Unlock(); }
// Attributes:
private:
CMIUtilThreadMutex &m_rMutex;
};
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h
|
<filename>SymbolExtractorAndRenamer/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h
//===-- PlatformFreeBSD.h ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_PlatformFreeBSD_h_
#define liblldb_PlatformFreeBSD_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/Platform.h"
namespace lldb_private {
namespace platform_freebsd {
class PlatformFreeBSD : public Platform {
public:
PlatformFreeBSD(bool is_host);
~PlatformFreeBSD() override;
//------------------------------------------------------------
// Class functions
//------------------------------------------------------------
static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
static void Initialize();
static void Terminate();
static ConstString GetPluginNameStatic(bool is_host);
static const char *GetDescriptionStatic(bool is_host);
//------------------------------------------------------------
// lldb_private::PluginInterface functions
//------------------------------------------------------------
ConstString GetPluginName() override { return GetPluginNameStatic(IsHost()); }
uint32_t GetPluginVersion() override { return 1; }
const char *GetDescription() override {
return GetDescriptionStatic(IsHost());
}
//------------------------------------------------------------
// lldb_private::Platform functions
//------------------------------------------------------------
bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
ModuleSpec &module_spec) override;
Error RunShellCommand(const char *command, const FileSpec &working_dir,
int *status_ptr, int *signo_ptr,
std::string *command_output,
uint32_t timeout_sec) override;
Error ResolveExecutable(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr) override;
size_t GetSoftwareBreakpointTrapOpcode(Target &target,
BreakpointSite *bp_site) override;
bool GetRemoteOSVersion() override;
bool GetRemoteOSBuildString(std::string &s) override;
bool GetRemoteOSKernelDescription(std::string &s) override;
// Remote Platform subclasses need to override this function
ArchSpec GetRemoteSystemArchitecture() override;
bool IsConnected() const override;
Error ConnectRemote(Args &args) override;
Error DisconnectRemote() override;
const char *GetHostname() override;
const char *GetUserName(uint32_t uid) override;
const char *GetGroupName(uint32_t gid) override;
bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
ProcessInstanceInfoList &process_infos) override;
Error LaunchProcess(ProcessLaunchInfo &launch_info) override;
lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
Target *target, Error &error) override;
// FreeBSD processes can not be launched by spawning and attaching.
bool CanDebugProcess() override { return false; }
// Only on PlatformMacOSX:
Error GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid,
FileSpec &local_file) override;
Error GetSharedModule(const ModuleSpec &module_spec, Process *process,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr,
lldb::ModuleSP *old_module_sp_ptr,
bool *did_create_ptr) override;
bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;
void GetStatus(Stream &strm) override;
void CalculateTrapHandlerSymbolNames() override;
protected:
lldb::PlatformSP m_remote_platform_sp; // Allow multiple ways to connect to a
// remote freebsd OS
private:
DISALLOW_COPY_AND_ASSIGN(PlatformFreeBSD);
};
} // namespace platform_freebsd
} // namespace lldb_private
#endif // liblldb_PlatformFreeBSD_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
|
<filename>SymbolExtractorAndRenamer/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
//===-- ThreadGDBRemote.h ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ThreadGDBRemote_h_
#define liblldb_ThreadGDBRemote_h_
// C Includes
// C++ Includes
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/StructuredData.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
class StringExtractor;
namespace lldb_private {
namespace process_gdb_remote {
class ProcessGDBRemote;
class ThreadGDBRemote : public Thread {
public:
ThreadGDBRemote(Process &process, lldb::tid_t tid);
~ThreadGDBRemote() override;
void WillResume(lldb::StateType resume_state) override;
void RefreshStateAfterStop() override;
const char *GetName() override;
const char *GetQueueName() override;
lldb::QueueKind GetQueueKind() override;
lldb::queue_id_t GetQueueID() override;
lldb::QueueSP GetQueue() override;
lldb::addr_t GetQueueLibdispatchQueueAddress() override;
void SetQueueLibdispatchQueueAddress(lldb::addr_t dispatch_queue_t) override;
bool ThreadHasQueueInformation() const override;
lldb::RegisterContextSP GetRegisterContext() override;
lldb::RegisterContextSP
CreateRegisterContextForFrame(StackFrame *frame) override;
void Dump(Log *log, uint32_t index);
static bool ThreadIDIsValid(lldb::tid_t thread);
bool ShouldStop(bool &step_more);
const char *GetBasicInfoAsString();
void SetName(const char *name) override {
if (name && name[0])
m_thread_name.assign(name);
else
m_thread_name.clear();
}
lldb::addr_t GetThreadDispatchQAddr() { return m_thread_dispatch_qaddr; }
void SetThreadDispatchQAddr(lldb::addr_t thread_dispatch_qaddr) {
m_thread_dispatch_qaddr = thread_dispatch_qaddr;
}
void ClearQueueInfo();
void SetQueueInfo(std::string &&queue_name, lldb::QueueKind queue_kind,
uint64_t queue_serial, lldb::addr_t dispatch_queue_t,
lldb_private::LazyBool associated_with_libdispatch_queue);
lldb_private::LazyBool GetAssociatedWithLibdispatchQueue() override;
void SetAssociatedWithLibdispatchQueue(
lldb_private::LazyBool associated_with_libdispatch_queue) override;
StructuredData::ObjectSP FetchThreadExtendedInfo() override;
protected:
friend class ProcessGDBRemote;
std::string m_thread_name;
std::string m_dispatch_queue_name;
lldb::addr_t m_thread_dispatch_qaddr;
lldb::addr_t m_dispatch_queue_t;
lldb::QueueKind
m_queue_kind; // Queue info from stop reply/stop info for thread
uint64_t
m_queue_serial_number; // Queue info from stop reply/stop info for thread
lldb_private::LazyBool m_associated_with_libdispatch_queue;
bool PrivateSetRegisterValue(uint32_t reg, llvm::ArrayRef<uint8_t> data);
bool PrivateSetRegisterValue(uint32_t reg, uint64_t regval);
bool CachedQueueInfoIsValid() const {
return m_queue_kind != lldb::eQueueKindUnknown;
}
void SetStopInfoFromPacket(StringExtractor &stop_packet, uint32_t stop_id);
bool CalculateStopInfo() override;
};
} // namespace process_gdb_remote
} // namespace lldb_private
#endif // liblldb_ThreadGDBRemote_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/clang/test/Index/Store/unit-with-vfs.c
|
// RUN: sed -e "s:INPUT_DIR:%S/Inputs:g" -e "s:OUT_DIR:%t:g" %S/Inputs/overlay.yaml > %t.yaml
// REQUIRES: shell
#include "using-overlay.h"
// RUN: rm -rf %t.idx
// RUN: %clang_cc1 %s -index-store-path %t.idx -I %t -ivfsoverlay %t.yaml
// RUN: c-index-test core -print-unit %t.idx | FileCheck %s
// XFAIL: linux
// CHECK: Record | user | {{.*}}test/Index/Store/Inputs/using-overlay.h
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Core/ValueObjectCast.h
|
<filename>SymbolExtractorAndRenamer/lldb/include/lldb/Core/ValueObjectCast.h
//===-- ValueObjectDynamicValue.h -------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ValueObjectCast_h_
#define liblldb_ValueObjectCast_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ValueObject.h"
namespace lldb_private {
//---------------------------------------------------------------------------------
// A ValueObject that represents a given value represented as a different type.
//---------------------------------------------------------------------------------
class ValueObjectCast : public ValueObject {
public:
~ValueObjectCast() override;
static lldb::ValueObjectSP Create(ValueObject &parent,
const ConstString &name,
const CompilerType &cast_type);
uint64_t GetByteSize() override;
size_t CalculateNumChildren(uint32_t max) override;
lldb::ValueType GetValueType() const override;
bool IsInScope() override;
ValueObject *GetParent() override {
return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
}
const ValueObject *GetParent() const override {
return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
}
protected:
ValueObjectCast(ValueObject &parent, const ConstString &name,
const CompilerType &cast_type);
bool UpdateValue() override;
CompilerType GetCompilerTypeImpl() override;
CompilerType m_cast_type;
private:
DISALLOW_COPY_AND_ASSIGN(ValueObjectCast);
};
} // namespace lldb_private
#endif // liblldb_ValueObjectCast_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/clang/test/CodeGen/mcount.c
|
// RUN: %clang_cc1 -pg -triple i386-unknown-unknown -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -pg -triple i386-unknown-unknown -emit-llvm -O2 -o - %s | FileCheck %s
// RUN: %clang_cc1 -pg -triple powerpc-unknown-gnu-linux -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple powerpc64-unknown-gnu-linux -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple powerpc64le-unknown-gnu-linux -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple i386-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple x86_64-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple arm-netbsd-eabi -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple aarch64-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple mips-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple powerpc-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple powerpc64-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple powerpc64le-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple sparc-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -pg -triple sparc64-netbsd -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-PREFIXED %s
// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s -check-prefix=NO-MCOUNT
int bar(void) {
return 0;
}
int foo(void) {
return bar();
}
int main(void) {
return foo();
}
// CHECK: attributes #{{[0-9]+}} = { {{.*}}"counting-function"="mcount"{{.*}} }
// CHECK-PREFIXED: attributes #{{[0-9]+}} = { {{.*}}"counting-function"="_mcount"{{.*}} }
// NO-MCOUNT-NOT: attributes #{{[0-9]}} = { {{.*}}"counting-function"={{.*}} }
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h
|
//===-- DWARFDIE.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef SymbolFileDWARF_DWARFDIE_h_
#define SymbolFileDWARF_DWARFDIE_h_
#include "lldb/Core/dwarf.h"
#include "lldb/lldb-types.h"
struct DIERef;
class DWARFASTParser;
class DWARFAttributes;
class DWARFCompileUnit;
class DWARFDebugInfoEntry;
class DWARFDeclContext;
class DWARFDIECollection;
class SymbolFileDWARF;
class DWARFDIE {
public:
DWARFDIE() : m_cu(nullptr), m_die(nullptr) {}
DWARFDIE(DWARFCompileUnit *cu, DWARFDebugInfoEntry *die)
: m_cu(cu), m_die(die) {}
DWARFDIE(const DWARFCompileUnit *cu, DWARFDebugInfoEntry *die)
: m_cu(const_cast<DWARFCompileUnit *>(cu)), m_die(die) {}
DWARFDIE(DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
: m_cu(cu), m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
DWARFDIE(const DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
: m_cu(const_cast<DWARFCompileUnit *>(cu)),
m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
//----------------------------------------------------------------------
// Tests
//----------------------------------------------------------------------
explicit operator bool() const { return IsValid(); }
bool IsValid() const { return m_cu && m_die; }
bool IsStructOrClass() const;
bool HasChildren() const;
bool Supports_DW_AT_APPLE_objc_complete_type() const;
//----------------------------------------------------------------------
// Accessors
//----------------------------------------------------------------------
SymbolFileDWARF *GetDWARF() const;
DWARFCompileUnit *GetCU() const { return m_cu; }
DWARFDebugInfoEntry *GetDIE() const { return m_die; }
DIERef GetDIERef() const;
lldb_private::TypeSystem *GetTypeSystem() const;
DWARFASTParser *GetDWARFParser() const;
void Set(DWARFCompileUnit *cu, DWARFDebugInfoEntry *die) {
if (cu && die) {
m_cu = cu;
m_die = die;
} else {
Clear();
}
}
void Clear() {
m_cu = nullptr;
m_die = nullptr;
}
lldb::ModuleSP GetContainingDWOModule() const;
DWARFDIE
GetContainingDWOModuleDIE() const;
//----------------------------------------------------------------------
// Accessing information about a DIE
//----------------------------------------------------------------------
dw_tag_t Tag() const;
const char *GetTagAsCString() const;
dw_offset_t GetOffset() const;
dw_offset_t GetCompileUnitRelativeOffset() const;
//----------------------------------------------------------------------
// Get the LLDB user ID for this DIE. This is often just the DIE offset,
// but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
// we are doing Darwin DWARF in .o file, or DWARF stand alone debug
// info.
//----------------------------------------------------------------------
lldb::user_id_t GetID() const;
const char *GetName() const;
const char *GetMangledName() const;
const char *GetPubname() const;
const char *GetQualifiedName(std::string &storage) const;
lldb::LanguageType GetLanguage() const;
lldb::ModuleSP GetModule() const;
lldb_private::CompileUnit *GetLLDBCompileUnit() const;
lldb_private::Type *ResolveType() const;
//----------------------------------------------------------------------
// Resolve a type by UID using this DIE's DWARF file
//----------------------------------------------------------------------
lldb_private::Type *ResolveTypeUID(const DIERef &die_ref) const;
//----------------------------------------------------------------------
// Functions for obtaining DIE relations and references
//----------------------------------------------------------------------
DWARFDIE
GetParent() const;
DWARFDIE
GetFirstChild() const;
DWARFDIE
GetSibling() const;
DWARFDIE
GetReferencedDIE(const dw_attr_t attr) const;
//----------------------------------------------------------------------
// Get a another DIE from the same DWARF file as this DIE. This will
// check the current DIE's compile unit first to see if "die_offset" is
// in the same compile unit, and fall back to checking the DWARF file.
//----------------------------------------------------------------------
DWARFDIE
GetDIE(dw_offset_t die_offset) const;
DWARFDIE
LookupDeepestBlock(lldb::addr_t file_addr) const;
DWARFDIE
GetParentDeclContextDIE() const;
//----------------------------------------------------------------------
// DeclContext related functions
//----------------------------------------------------------------------
void GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const;
void GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const;
void GetDWOContext(std::vector<lldb_private::CompilerContext> &context) const;
//----------------------------------------------------------------------
// Getting attribute values from the DIE.
//
// GetAttributeValueAsXXX() functions should only be used if you are
// looking for one or two attributes on a DIE. If you are trying to
// parse all attributes, use GetAttributes (...) instead
//----------------------------------------------------------------------
const char *GetAttributeValueAsString(const dw_attr_t attr,
const char *fail_value) const;
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr,
uint64_t fail_value) const;
int64_t GetAttributeValueAsSigned(const dw_attr_t attr,
int64_t fail_value) const;
uint64_t GetAttributeValueAsReference(const dw_attr_t attr,
uint64_t fail_value) const;
DWARFDIE
GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
uint64_t fail_value) const;
size_t GetAttributes(DWARFAttributes &attributes, uint32_t depth = 0) const;
bool GetDIENamesAndRanges(const char *&name, const char *&mangled,
DWARFRangeList &ranges, int &decl_file,
int &decl_line, int &decl_column, int &call_file,
int &call_line, int &call_column,
lldb_private::DWARFExpression *frame_base) const;
//----------------------------------------------------------------------
// Pretty printing
//----------------------------------------------------------------------
void Dump(lldb_private::Stream *s, const uint32_t recurse_depth) const;
lldb_private::CompilerDecl GetDecl() const;
lldb_private::CompilerDeclContext GetDeclContext() const;
lldb_private::CompilerDeclContext GetContainingDeclContext() const;
protected:
DWARFCompileUnit *m_cu;
DWARFDebugInfoEntry *m_die;
};
bool operator==(const DWARFDIE &lhs, const DWARFDIE &rhs);
bool operator!=(const DWARFDIE &lhs, const DWARFDIE &rhs);
#endif // SymbolFileDWARF_DWARFDIE_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/clang/test/Modules/module-impl-with-link.c
|
// RUN: rm -rf %t
// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -fmodule-name=Clib %s -I %S/Inputs/module-impl-with-link -emit-llvm -o -
#include "foo.h"
// CHECK: !{{[0-9]+}} = !{i32 6, !"Linker Options", ![[LINK_OPTIONS:[0-9]+]]}
// Make sure we don't generate linker option for module Clib since this TU is
// an implementation of Clib.
// CHECK: ![[LINK_OPTIONS]] = !{}
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/include/lldb/Core/DataEncoder.h
|
<reponame>Polidea/SiriusObfuscator
//===-- DataEncoder.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_DataEncoder_h_
#define liblldb_DataEncoder_h_
#if defined(__cplusplus)
#include "lldb/lldb-private.h"
#include <limits.h>
#include <stdint.h>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class DataEncoder DataEncoder.h "lldb/Core/DataEncoder.h"
/// @brief An binary data encoding class.
///
/// DataEncoder is a class that can encode binary data (swapping if needed)
/// to a data buffer. The data buffer can be caller owned, or can be
/// shared data that can be shared between multiple DataEncoder or
/// DataEncoder instances.
///
/// @see DataBuffer
//----------------------------------------------------------------------
class DataEncoder {
public:
//------------------------------------------------------------------
/// Default constructor.
///
/// Initialize all members to a default empty state.
//------------------------------------------------------------------
DataEncoder();
//------------------------------------------------------------------
/// Construct with a buffer that is owned by the caller.
///
/// This constructor allows us to use data that is owned by the
/// caller. The data must stay around as long as this object is
/// valid.
///
/// @param[in] data
/// A pointer to caller owned data.
///
/// @param[in] data_length
/// The length in bytes of \a data.
///
/// @param[in] byte_order
/// A byte order of the data that we are extracting from.
///
/// @param[in] addr_size
/// A new address byte size value.
//------------------------------------------------------------------
DataEncoder(void *data, uint32_t data_length, lldb::ByteOrder byte_order,
uint8_t addr_size);
//------------------------------------------------------------------
/// Construct with shared data.
///
/// Copies the data shared pointer which adds a reference to the
/// contained in \a data_sp. The shared data reference is reference
/// counted to ensure the data lives as long as anyone still has a
/// valid shared pointer to the data in \a data_sp.
///
/// @param[in] data_sp
/// A shared pointer to data.
///
/// @param[in] byte_order
/// A byte order of the data that we are extracting from.
///
/// @param[in] addr_size
/// A new address byte size value.
//------------------------------------------------------------------
DataEncoder(const lldb::DataBufferSP &data_sp, lldb::ByteOrder byte_order,
uint8_t addr_size);
//------------------------------------------------------------------
/// Destructor
///
/// If this object contains a valid shared data reference, the
/// reference count on the data will be decremented, and if zero,
/// the data will be freed.
//------------------------------------------------------------------
~DataEncoder();
//------------------------------------------------------------------
/// Clears the object state.
///
/// Clears the object contents back to a default invalid state, and
/// release any references to shared data that this object may
/// contain.
//------------------------------------------------------------------
void Clear();
//------------------------------------------------------------------
/// Get the current address size.
///
/// Return the size in bytes of any address values this object will
/// extract.
///
/// @return
/// The size in bytes of address values that will be extracted.
//------------------------------------------------------------------
uint8_t GetAddressByteSize() const { return m_addr_size; }
//------------------------------------------------------------------
/// Get the number of bytes contained in this object.
///
/// @return
/// The total number of bytes of data this object refers to.
//------------------------------------------------------------------
size_t GetByteSize() const { return m_end - m_start; }
//------------------------------------------------------------------
/// Get the data end pointer.
///
/// @return
/// Returns a pointer to the next byte contained in this
/// object's data, or NULL of there is no data in this object.
//------------------------------------------------------------------
uint8_t *GetDataEnd() { return m_end; }
const uint8_t *GetDataEnd() const { return m_end; }
//------------------------------------------------------------------
/// Get the shared data offset.
///
/// Get the offset of the first byte of data in the shared data (if
/// any).
///
/// @return
/// If this object contains shared data, this function returns
/// the offset in bytes into that shared data, zero otherwise.
//------------------------------------------------------------------
size_t GetSharedDataOffset() const;
//------------------------------------------------------------------
/// Get the current byte order value.
///
/// @return
/// The current byte order value from this object's internal
/// state.
//------------------------------------------------------------------
lldb::ByteOrder GetByteOrder() const { return m_byte_order; }
//------------------------------------------------------------------
/// Get the data start pointer.
///
/// @return
/// Returns a pointer to the first byte contained in this
/// object's data, or NULL of there is no data in this object.
//------------------------------------------------------------------
uint8_t *GetDataStart() { return m_start; }
const uint8_t *GetDataStart() const { return m_start; }
//------------------------------------------------------------------
/// Encode unsigned integer values into the data at \a offset.
///
/// @param[in] offset
/// The offset within the contained data at which to put the
/// data.
///
/// @param[in] value
/// The value to encode into the data.
///
/// @return
/// The next offset in the bytes of this data if the data
/// was successfully encoded, UINT32_MAX if the encoding failed.
//------------------------------------------------------------------
uint32_t PutU8(uint32_t offset, uint8_t value);
uint32_t PutU16(uint32_t offset, uint16_t value);
uint32_t PutU32(uint32_t offset, uint32_t value);
uint32_t PutU64(uint32_t offset, uint64_t value);
//------------------------------------------------------------------
/// Encode an unsigned integer of size \a byte_size to \a offset.
///
/// Encode a single integer value at \a offset and return the offset
/// that follows the newly encoded integer when the data is successfully
/// encoded into the existing data. There must be enough room in the
/// data, else UINT32_MAX will be returned to indicate that encoding
/// failed.
///
/// @param[in] offset
/// The offset within the contained data at which to put the
/// encoded integer.
///
/// @param[in] byte_size
/// The size in byte of the integer to encode.
///
/// @param[in] value
/// The integer value to write. The least significant bytes of
/// the integer value will be written if the size is less than
/// 8 bytes.
///
/// @return
/// The next offset in the bytes of this data if the integer
/// was successfully encoded, UINT32_MAX if the encoding failed.
//------------------------------------------------------------------
uint32_t PutMaxU64(uint32_t offset, uint32_t byte_size, uint64_t value);
//------------------------------------------------------------------
/// Encode an arbitrary number of bytes.
///
/// @param[in] offset
/// The offset in bytes into the contained data at which to
/// start encoding.
///
/// @param[in] src
/// The buffer that contains the bytes to encode.
///
/// @param[in] src_len
/// The number of bytes to encode.
///
/// @return
/// The next valid offset within data if the put operation
/// was successful, else UINT32_MAX to indicate the put failed.
//------------------------------------------------------------------
uint32_t PutData(uint32_t offset, const void *src, uint32_t src_len);
//------------------------------------------------------------------
/// Encode an address in the existing buffer at \a offset bytes into
/// the buffer.
///
/// Encode a single address (honoring the m_addr_size member) to
/// the data and return the next offset where subsequent data would
/// go.
/// pointed to by \a offset_ptr. The size of the extracted address
/// comes from the \a m_addr_size member variable and should be
/// set correctly prior to extracting any address values.
///
/// @param[in,out] offset_ptr
/// A pointer to an offset within the data that will be advanced
/// by the appropriate number of bytes if the value is extracted
/// correctly. If the offset is out of bounds or there are not
/// enough bytes to extract this value, the offset will be left
/// unmodified.
///
/// @return
/// The next valid offset within data if the put operation
/// was successful, else UINT32_MAX to indicate the put failed.
//------------------------------------------------------------------
uint32_t PutAddress(uint32_t offset, lldb::addr_t addr);
//------------------------------------------------------------------
/// Put a C string to \a offset.
///
/// Encodes a C string into the existing data including the
/// terminating
///
/// @param[in,out] offset_ptr
/// A pointer to an offset within the data that will be advanced
/// by the appropriate number of bytes if the value is extracted
/// correctly. If the offset is out of bounds or there are not
/// enough bytes to extract this value, the offset will be left
/// unmodified.
///
/// @return
/// A pointer to the C string value in the data. If the offset
/// pointed to by \a offset_ptr is out of bounds, or if the
/// offset plus the length of the C string is out of bounds,
/// NULL will be returned.
//------------------------------------------------------------------
uint32_t PutCString(uint32_t offset_ptr, const char *cstr);
lldb::DataBufferSP &GetSharedDataBuffer() { return m_data_sp; }
//------------------------------------------------------------------
/// Set the address byte size.
///
/// Set the size in bytes that will be used when extracting any
/// address and pointer values from data contained in this object.
///
/// @param[in] addr_size
/// The size in bytes to use when extracting addresses.
//------------------------------------------------------------------
void SetAddressByteSize(uint8_t addr_size) { m_addr_size = addr_size; }
//------------------------------------------------------------------
/// Set data with a buffer that is caller owned.
///
/// Use data that is owned by the caller when extracting values.
/// The data must stay around as long as this object, or any object
/// that copies a subset of this object's data, is valid. If \a
/// bytes is NULL, or \a length is zero, this object will contain
/// no data.
///
/// @param[in] bytes
/// A pointer to caller owned data.
///
/// @param[in] length
/// The length in bytes of \a bytes.
///
/// @param[in] byte_order
/// A byte order of the data that we are extracting from.
///
/// @return
/// The number of bytes that this object now contains.
//------------------------------------------------------------------
uint32_t SetData(void *bytes, uint32_t length, lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Adopt a subset of shared data in \a data_sp.
///
/// Copies the data shared pointer which adds a reference to the
/// contained in \a data_sp. The shared data reference is reference
/// counted to ensure the data lives as long as anyone still has a
/// valid shared pointer to the data in \a data_sp. The byte order
/// and address byte size settings remain the same. If
/// \a offset is not a valid offset in \a data_sp, then no reference
/// to the shared data will be added. If there are not \a length
/// bytes available in \a data starting at \a offset, the length
/// will be truncated to contains as many bytes as possible.
///
/// @param[in] data_sp
/// A shared pointer to data.
///
/// @param[in] offset
/// The offset into \a data_sp at which the subset starts.
///
/// @param[in] length
/// The length in bytes of the subset of \a data_sp.
///
/// @return
/// The number of bytes that this object now contains.
//------------------------------------------------------------------
uint32_t SetData(const lldb::DataBufferSP &data_sp, uint32_t offset = 0,
uint32_t length = UINT32_MAX);
//------------------------------------------------------------------
/// Set the byte_order value.
///
/// Sets the byte order of the data to extract. Extracted values
/// will be swapped if necessary when decoding.
///
/// @param[in] byte_order
/// The byte order value to use when extracting data.
//------------------------------------------------------------------
void SetByteOrder(lldb::ByteOrder byte_order) { m_byte_order = byte_order; }
//------------------------------------------------------------------
/// Test the validity of \a offset.
///
/// @return
/// \b true if \a offset is a valid offset into the data in this
/// object, \b false otherwise.
//------------------------------------------------------------------
bool ValidOffset(uint32_t offset) const { return offset < GetByteSize(); }
//------------------------------------------------------------------
/// Test the availability of \a length bytes of data from \a offset.
///
/// @return
/// \b true if \a offset is a valid offset and there are \a
/// length bytes available at that offset, \b false otherwise.
//------------------------------------------------------------------
bool ValidOffsetForDataOfSize(uint32_t offset, uint32_t length) const {
return length <= BytesLeft(offset);
}
uint32_t BytesLeft(uint32_t offset) const {
const uint32_t size = GetByteSize();
if (size > offset)
return size - offset;
return 0;
}
protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
uint8_t *m_start; ///< A pointer to the first byte of data.
uint8_t *m_end; ///< A pointer to the byte that is past the end of the data.
lldb::ByteOrder
m_byte_order; ///< The byte order of the data we are extracting from.
uint8_t m_addr_size; ///< The address size to use when extracting pointers or
///addresses
mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can
///be shared among multiple instances
private:
DISALLOW_COPY_AND_ASSIGN(DataEncoder);
};
} // namespace lldb_private
#endif // #if defined (__cplusplus)
#endif // #ifndef liblldb_DataEncoder_h_
|
Polidea/SiriusObfuscator
|
SymbolExtractorAndRenamer/lldb/source/Plugins/ExpressionParser/Swift/SwiftPersistentExpressionState.h
|
<reponame>Polidea/SiriusObfuscator
//===-- SwiftPersistentExpressionState.h ------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_SwiftPersistentExpressionState_h_
#define liblldb_SwiftPersistentExpressionState_h_
#include "SwiftExpressionVariable.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
#include <set>
#include <string>
#include <unordered_map>
namespace lldb_private {
//----------------------------------------------------------------------
/// @class SwiftPersistentExpressionState SwiftPersistentExpressionState.h
/// "lldb/Expression/SwiftPersistentExpressionState.h"
/// @brief Manages persistent values that need to be preserved between
/// expression invocations.
///
/// A list of variables that can be accessed and updated by any expression. See
/// ClangPersistentVariable for more discussion. Also provides an increasing,
/// 0-based counter for naming result variables.
//----------------------------------------------------------------------
class SwiftPersistentExpressionState : public PersistentExpressionState {
public:
class SwiftDeclMap {
public:
void AddDecl(swift::ValueDecl *decl, bool check_existing,
const ConstString &name);
bool FindMatchingDecls(const ConstString &name,
std::vector<swift::ValueDecl *> &matches);
void CopyDeclsTo(SwiftDeclMap &target_map);
static bool DeclsAreEquivalent(swift::Decl *lhs, swift::Decl *rhs);
private:
typedef std::unordered_multimap<std::string, swift::ValueDecl *>
SwiftDeclMapTy;
typedef SwiftDeclMapTy::iterator iterator;
SwiftDeclMapTy m_swift_decls;
};
//----------------------------------------------------------------------
/// Constructor
//----------------------------------------------------------------------
SwiftPersistentExpressionState();
~SwiftPersistentExpressionState() {}
//------------------------------------------------------------------
// llvm casting support
//------------------------------------------------------------------
static bool classof(const PersistentExpressionState *pv) {
return pv->getKind() == PersistentExpressionState::eKindClang;
}
lldb::ExpressionVariableSP
CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override;
lldb::ExpressionVariableSP CreatePersistentVariable(
ExecutionContextScope *exe_scope, const ConstString &name,
const CompilerType &compiler_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) override;
//----------------------------------------------------------------------
/// Return the next entry in the sequence of strings "$0", "$1", ... for
/// use naming persistent expression convenience variables.
///
/// @param[in] language_type
/// The language for the expression, which can affect the prefix
///
/// @param[in] is_error
/// If true, an error variable name is produced.
///
/// @return
/// A string that contains the next persistent variable name.
//----------------------------------------------------------------------
ConstString GetNextPersistentVariableName(bool is_error = false) override;
void RemovePersistentVariable(lldb::ExpressionVariableSP variable) override;
void RegisterSwiftPersistentDecl(swift::ValueDecl *value_decl);
void RegisterSwiftPersistentDeclAlias(swift::ValueDecl *value_decl,
const ConstString &name);
void CopyInSwiftPersistentDecls(SwiftDeclMap &source_map);
bool GetSwiftPersistentDecls(const ConstString &name,
std::vector<swift::ValueDecl *> &matches);
// This just adds this module to the list of hand-loaded modules, it doesn't
// actually load it.
void AddHandLoadedModule(const ConstString &module_name) {
m_hand_loaded_modules.insert(module_name);
}
using HandLoadedModuleCallback = std::function<bool(const ConstString)>;
bool RunOverHandLoadedModules(HandLoadedModuleCallback callback) {
for (ConstString name : m_hand_loaded_modules) {
if (!callback(name))
return false;
}
return true;
}
private:
uint32_t m_next_persistent_variable_id; ///< The counter used by
///GetNextResultName().
uint32_t m_next_persistent_error_id; ///< The counter used by
///GetNextResultName() when is_error is
///true.
SwiftDeclMap m_swift_persistent_decls; ///< The persistent functions declared
///by the user.
typedef std::set<lldb_private::ConstString> HandLoadedModuleSet;
HandLoadedModuleSet m_hand_loaded_modules; ///< These are the names of modules
///that we have loaded by
///< hand into the Contexts we make for parsing.
};
}
#endif
|
reitiscapital/ReitisWallet-Core
|
src/qt/qtipcserver.h
|
<reponame>reitiscapital/ReitisWallet-Core
#ifndef QTIPCSERVER_H
#define QTIPCSERVER_H
// Define REITIS-Core message queue name
#define BITCOINURI_QUEUE_NAME "REITISURI"
void ipcScanRelay(int argc, char *argv[]);
void ipcInit(int argc, char *argv[]);
#endif // QTIPCSERVER_H
|
adityapandey2811/data-structures
|
SquareRootNthNode.c
|
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node* fractionalNode(node *head){
node *temp = NULL;
int i=1,k=1;
while(head){
if(i == k*k){
if(temp == NULL)
temp = head;
else
temp = temp->next;
k++;
}
i++;
head = head->next;
}
return temp;
}
void main(){
int i;
node *head = NULL,*temp;
for(i=0;i<16;i++){
head = insertAtEnd(head);
}
temp = fractionalNode(head);
printf("%d\n",temp->data);
}
|
adityapandey2811/data-structures
|
SeperateAlternateLists.c
|
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node* seperateLists(node **head){
node *temp1 , *temp2, *spare = *head, *rnode;
if(spare == NULL || spare->next == NULL)
return NULL;
temp1 = *head;
temp2 = temp1->next;
rnode = temp2;
spare = spare->next->next;
while(spare){
temp1->next = spare;
temp1 = temp1->next;
spare = spare->next;
temp2->next = spare;
temp2 = temp2->next;
spare = spare->next;
}
temp1->next = NULL;
temp2->next = NULL;
return rnode;
}
void main(){
int i;
node *head1 = NULL, *head2 = NULL;
for(i=0;i<10;i++)
head1 = insertAtEnd(head1);
head2 = seperateLists(&head1);
display(head1);
display(head2);
}
|
adityapandey2811/data-structures
|
SeperateEvenOddData.c
|
<reponame>adityapandey2811/data-structures<gh_stars>1-10
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node *evenOddConundrum(node *head){
node *temp = head,*spare = NULL, *link = NULL,*even = NULL,*odd = NULL;
while(temp){
if(temp->data%2==0){
if(spare == NULL)
spare = temp;
else
even->next = temp;
even = temp;
}
else{
if(link == NULL)
link = temp;
else
odd->next = temp;
odd = temp;
}
temp = temp->next;
}
if(even!=NULL)
even->next = link;
if(odd!=NULL)
odd->next = NULL;
if(spare!=NULL)
return spare;
else
return link;
}
void main(){
node *head = NULL;
int i;
for(i=0;i<2;i++){
head = insertAtEnd(head);
}
head = evenOddConundrum(head);
display(head);
}
|
adityapandey2811/data-structures
|
ReverseList.c
|
<filename>ReverseList.c
//Aditya’s code for reversing list
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node *reverse(node *head){
node *temp = head,*prev = NULL,*link = NULL;
//Reversing list
while(temp){
link = temp->next;
temp->next = prev;
prev = temp;
temp = link;
}
head = prev;
return head;
}
//Main function
void main(){
node *head = NULL;
//Creating list
for(int i=10;i>0;i--){
head = insertAtEnd(head);
}
head = reverse(head);
display(head);
}
|
adityapandey2811/data-structures
|
PartitionList.c
|
<gh_stars>1-10
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node* partitionList(node *head, int X){
int i = 0;
node *lessThanX = NULL, *current = NULL, *moreThanX = NULL, *temp = head, *l, *m;
lessThanX = (node*)malloc(sizeof(node));
moreThanX = (node*)malloc(sizeof(node));
l = lessThanX;
m = moreThanX;
while(temp){
if(temp->data >= X){
if(temp->data == X && i==0){
current = temp;
i++;
}
else{
moreThanX->next = temp;
moreThanX = moreThanX->next;
}
}
else{
lessThanX->next = temp;
lessThanX = lessThanX->next;
}
temp = temp->next;
}
if(current!=NULL){
lessThanX->next = current;
lessThanX = lessThanX->next;
}
lessThanX->next = m->next;
free(m);
moreThanX->next = NULL;
lessThanX = l->next;
free(l);
return lessThanX;
}
void main(){
int i;
node *head = NULL, *temp = NULL;
for(i=0;i<10;i++){
head = insertAtEnd(head);
}
printf("Enter partition value: ");
scanf("%d",&i);
temp = partitionList(head,i);
display(temp);
}
|
adityapandey2811/data-structures
|
RecursiveListReverse.c
|
//Aditya’s code for recursive list reverse
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node *reverse(node *head,node *temp){
//Reversing
node *final;
if(head->next==NULL){
final = head;
}
else if(head->next!=NULL){
temp = head;
head = head->next;
reverse(head,temp);
}
head->next = temp;
if(temp!=NULL){
temp->next = NULL;
}
return final;
}
//Main function
void main(){
node *head = NULL;
//Creating list
for(int i=10;i>0;i--){
head = insertAtEnd(head);
}
head = reverse(head,NULL);
display(head);
}
|
adityapandey2811/data-structures
|
NthNodeFromEnd.c
|
//nth node from end
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
int main(){
int i,n,k;
node *head = NULL,*temp;
for(i = 10;i > 0;i--){
head = insertAtEnd(head);
}
printf("Enter k: ");
scanf("%d",&k);
n = length(head);
if(n>=k && k>0){
n-=k;
temp =head;
while(n--){
temp=temp->next;
}
printf("kth Node: %d\n",temp->data);
}
else{
printf("Invalid Number!!!\n");
}
return 0;
}
|
adityapandey2811/data-structures
|
InsertingInSortedList.c
|
//Aditya’s code for inserting in sorted list
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
node *insert(node *head){
node *new = NULL,*temp = head,*prev = NULL;
int i,j,k,n,flag = 0;
//Creating node
new = (node*)malloc(sizeof(node));
new->next = NULL;
printf("Enter data: ");
scanf("%d",&new->data);
//Traversing sorted list and inserting value
while(temp->next){
if(new->data>temp->data){
prev = temp;
temp = temp->next;
}
if(new->data<=temp->data){
if(temp!=head){
prev->next = new;
new->next = temp;
flag = 1;
break;
}
else{
new->next = head;
head = new;
flag = 1;
break;
}
}
}
if(!flag){
temp->next = new;
}
return head;
}
//Main function
void main(){
node *head = NULL;
int i,j,k,n;
//Creating linked list
for(i=5;i>0;i--){
head = insertAtEnd(head);
}
head = insert(head);
display(head);
}
|
adityapandey2811/data-structures
|
ReverseListDisplayRecursive.c
|
//Aditya’s code for backward list display
#include<stdio.h>
#include<stdlib.h>
#include"ll.h"
//Displaying using recursion
void recursiveDisplay(node *head){
if(head->next!=NULL){
recursiveDisplay(head->next);
}
printf("%d ",head->data);
}
//Main Function
void main(){
int i;
node *head = NULL;
for(i=10;i>0;i--){
head = insertAtEnd(head);
}
recursiveDisplay(head);
}
|
adityapandey2811/data-structures
|
XorLinkedListStarter.c
|
//Aditya's code for xor linked list(memory efficient doubly linked list)
#include<stdio.h>
#include<stdlib.h>
#include<inttypes.h>
typedef struct n{
int data;
struct n *next;
}node;
//Convert links to XOR
node *xor(node *prev, node *next){
return (node*) ((uintptr_t) (prev) ^ (uintptr_t) (next));
}
//Display
void display(node *head){
node *temp = head;
while(temp){
printf("%d ",temp->data);
temp = temp->next;
}
printf("\n");
}
//Insertion
node *insert(node *head){
int i=1;
node *temp,*newnode;
while(i){
printf("Enter: ");
newnode = (node*)malloc(sizeof(node));
newnode->next = NULL;
scanf("%d",&i);
newnode->data = i;
if(head == NULL){
head = newnode;
}
else{
temp->next = newnode;
}
temp = newnode;
}
printf("List Created!!!\n");
display(head);
return head;
}
//Xor Display
void displayAterConversion(node *head){
node *temp = head,*new = NULL,*link = NULL;
while(temp){
new = temp;
printf("%d ",temp->data);
link = xor(link,temp->next);
if(link==NULL){
break;
}
temp = link;
link = new;
}
printf("\nBackward Traversal\n");
link = NULL;
while(temp){
new = temp;
printf("%d ",temp->data);
link = xor(link,temp->next);
if(link == NULL){
break;
}
temp = link;
link = new;
}
printf("\n");
}
//Convert to Xor
node *convertToDoubly(node *head){
node *temp = head,*new = head,*link = NULL;
while(temp){
link = temp->next;
if(temp == head){
temp->next = xor(NULL,temp->next);
}
else{
temp->next = xor(new,link);
new = temp;
}
temp = link;
}
return head;
}
//Main Function
void main(){
node *head = NULL;
head = insert(head);
head = convertToDoubly(head);
printf("List converted to memory efficient doubly linked list\n");
displayAterConversion(head);
}
|
adityapandey2811/data-structures
|
SinglyLinkedListStarter.c
|
//Aditys’s Code for SinglyLinkList
#include<stdio.h>
#include<stdlib.h>
typedef struct n{
int data;
struct n *next;
}node;
//Display Linked list
void display(node *head){
node *d = head;
if(d == NULL){
printf("List Empty\n");
}
while(d!=NULL){
printf("%d ",d->data);
d=d->next;
}
printf("\n");
}
//Length Linked List
int length(node *head){
int i=1;
node *temp = head;
if(temp == NULL){
printf("List Empty\n");
}
while(temp!=NULL){
temp = temp->next;
i++;
}
return i;
}
//Insertion Linked List
node* insertAtStart(node *head){
node *temp = head,*new;
new = (node*)malloc(sizeof(node));
new->next = NULL;
printf("Enter Data: ");
scanf("%d",&new->data);
if(temp == NULL){
head = new;
}
else{
new->next = head;
head = new;
}
return head;
}
node* insertAtGivenPostition(node *head){
int i,j,k,n,x,v,c;
node *temp = head,*new;
new = (node*)malloc(sizeof(node));
new->next = NULL;
printf("Enter Data: ");
scanf("%d",&new->data);
printf("Enter Position: ");
scanf("%d",&n);
if(head == NULL){
head = new;
}
else if(n<=1){
new->next = head;
head = new;
}
else if(n >= length(head)){
while(temp->next){
temp = temp->next;
}
temp->next = new;
}
else{
while((n--)-2>0){
temp = temp->next;
}
new->next = temp->next;
temp->next = new;
}
return head;
}
node* insertAtEnd(node *head){
node *temp = head,*new;
new = (node*)malloc(sizeof(node));
new->next = NULL;
printf("Enter Data: ");
scanf("%d",&new->data);
if(head == NULL){
head = new;
}
else{
while(temp->next){
temp = temp->next;
}
temp->next = new;
}
return head;
}
//Deletion Linked List
node* deleteAtStart(node *head){
node *temp = head;
if(temp == NULL){
printf("List Empty\n");
}
else{
head = head->next;
temp->next = NULL;
free(temp);
}
return head;
}
node* deleteAtEnd(node *head){
node *temp = head,*new = head;
if(temp == NULL){
printf("List Empty\n");
}
else if(temp->next!=NULL){
while(temp->next){
new = temp;
temp = temp->next;
}
temp->next = NULL;
free(temp);
new->next = NULL;
}
else{
head = NULL;
free(temp);
}
return head;
}
node* deleteAtGivenPosition(node *head){
int i,j,k,n,x,v,c;
node *temp = head,*new;
printf("Enter position: ");
scanf("%d",&n);
if(head == NULL){
printf("List Empty\n");
}
else if(n<=1){
head = deleteAtStart(head);
}
else if(n >= length(head)-1){
head = deleteAtEnd(head);
}
else{
while(n-2>0){
temp = temp->next;
n--;
}
new = temp->next;
temp->next = new->next;
new->next = NULL;
free(new);
}
return head;
}
node* deleteList(node *head){
node *temp;
if(temp == NULL){
printf("List Empty\n");
}
else{
while(head!=NULL){
temp = head;
head = head->next;
free(temp);
}
}
return head;
}
//Main Function
void main(){
node *head = NULL;
int i=0,j,k,n,x,v,c;
printf("Enter:\n1. Insert at start\n2. Insert at a given position\n3. Insert at end\n4. Display\n5. Length\n6. Delete at start\n7. Delete at a given position\n8. Delete at end\n9. Delete list\n10. End\n");
while(i!=10){
printf("Enter: ");
scanf("%d",&i);
if(i==1)
head = insertAtStart(head);
else if(i==2)
head = insertAtGivenPostition(head);
else if(i==3)
head = insertAtEnd(head);
else if(i==4)
display(head);
else if(i==5)
printf("Length: %d\n",(length(head)-1));
else if(i==6)
head = deleteAtStart(head);
else if(i==7)
head = deleteAtGivenPosition(head);
else if(i==8)
head = deleteAtEnd(head);
else if(i==9)
head = deleteList(head);
}
}
|
AdelBenAshraf/online_library_system
|
online_library_system_classes/UserList.h
|
#ifndef OOP_ASSIGNMENT2_USERLIST_H
#define OOP_ASSIGNMENT2_USERLIST_H
#include "User.h"
#include "Book.h"
class UserList {
private:
User* users_;
int capacity_;
int usersCount_;
public:
UserList(int);
UserList(const UserList&);
void addUser(User);// at the end of the array.
User& searchUser(string);
User& searchUser(int);
void deleteUser(int);
void operator=(const UserList&);
friend ostream &operator << (ostream &output, UserList &);
~UserList();
};
#endif
|
AdelBenAshraf/online_library_system
|
online_library_system_classes/Book.h
|
<filename>online_library_system_classes/Book.h
/*
@author <NAME>
@Explaination: This is.h Bookwhich is responsible for making objects of
type Books which have these attributes: (title, ISBN, ID, Category, author and average rating).
It have setters and getters for every attribute, have the equality operator overloading, input operator overloading, output operator overloading and a function to be used for rating books.
..........
*/
#ifndef OOP_ASSIGNMENT2_BOOK_H
#define OOP_ASSIGNMENT2_BOOK_H
#include<cstring>
#include<iostream>
#include "User.h"
using namespace std;
class Book {
private:
string title_;
string isbn_;// International Standard Book Number
int id_;
string category_;
float averageRating_;// this variable should contain the average rating for the book, rateBook function
float countRating;// This used to count the number of ratings of the book.
int sumRating;// This used to sum the ratings.
static int count;// This used to increment the ID variable
User author_;
public:
Book();// This is the default constructor.
Book(string , string , string);// This is the parameterized constructor.
Book(const Book&);// This is the copying constructor which use references to improve memory using efficiency.
void setTitle(string);// This used for setting the title as obvious, It takes a parameter of type string.
string getTitle();// This used for getting the title.
void setIsbn(string );// This used for setting the ISBN, It takes a parameter of type string.
string getIsbn();// This used for getting the ISBN.
void setId();// This used for setting the ID.
void setId(int id);
int getId();// This used for getting the ID.
void setCategory(string);// This used for setting the category of the book, It takes a parameter of type string.
string getCategory();// This used for getting the category of the book.
void setAuthor(User);// This for setting the author, it takes a parameter of type User.
User getAuthor();// This for getting the author.
void rateBook(float);// This function to calculate and update the book rating, and it takes a parameter of type string.
float getAverageRating();
bool operator == (const Book&); // This is an equality operator overloading.
friend ostream &operator<<(ostream &output, const Book &); // This friend function is the output operator overloading.
friend istream &operator>>( istream &input, Book &);// This friend function is the input operator overloading.
};
#endif
|
AdelBenAshraf/online_library_system
|
online_library_system_classes/User.h
|
<reponame>AdelBenAshraf/online_library_system<filename>online_library_system_classes/User.h<gh_stars>0
/*
@author <NAME>
@Explaination: This User.h which have the declaration of the attribute and methods for the class which make type users
which have these attributes (name, age, email, password, id) and It have setters and getters for every attribute,
have the equality operator overloading, input operator overloading and output operator overloading.
.............
*/
#ifndef OOP_ASSIGNMENT2_USER_H
#define OOP_ASSIGNMENT2_USER_H
#include <cstring>
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
class User {
private:
string name_;
int age_;
int id_;
string password_;
string email_;
public:
static int count;// This used to increment the ID attribute.
User();// This the default constructor.
User(string, int, string, string);//This is the parameterized constructor.
User(const User&);//This is the copying constructor and it is using reference to avoid copying by value and avoid wasting memory.
bool operator == (const User&);// This is an equality operator overloading to compare to users to each other.
void setName(string); // This function takes one parameter which is string to set the name.
string getName() const;// This function used for getting the name.
void setPassword(string);// This function takes one parameter which is string to set the password.
string getPassword() const;// This function used for getting the password.
void setEmail(string);// This function takes one parameter which is string to set the email.
string getEmail();// This function used for getting the email.
void setAge(int);// This function takes one parameter which is int to set the age.
int getAge();// This function used for getting the age.
void setId();// This function for setting the Id.
void setId(int);
int getId();// // This function used for getting the Id.
friend ostream &operator<<(ostream &output, const User &);// This friend function is the output operator overloading.
friend istream &operator>>(istream &input, User &);// This friend function is the input operator overloading.
};
#endif
|
AdelBenAshraf/online_library_system
|
online_library_system_classes/BookList.h
|
#ifndef OOP_ASSIGNMENT2_BOOKLIST_H
#define OOP_ASSIGNMENT2_BOOKLIST_H
#include "Book.h"
class BookList {
private:
Book* books_;
int capacity_;
int booksCount_;
public:
BookList(const BookList&);
BookList(int);
Book& searchBook(string);
Book& searchBook(int);
void addBook(Book);
void deleteBook(int);
Book& getTheHighestRatedBook();
Book* getBooksForUser(User); // get all books of this author.
Book & operator [] (int);
void operator= (const BookList&);
friend ostream & operator << (ostream &, BookList&);
~BookList();
};
#endif
|
sethvoltz/dotfiles
|
zsh/src/colorize.c
|
/* $Id: colorize.c 3816 2004-07-03 17:01:32Z lefevre $
*
* Colorize the standard input. Written for zsh stderr coloring.
* Found at http://www.zsh.org/mla/users/2004/msg00804.html
* Compile with `gcc colorize.c -o colorize` and move to bin folder
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/types.h>
#define BUFFSIZE 1024
static volatile sig_atomic_t usr1;
static void sigusr1(int sig)
{
usr1 = 1;
}
static void writepid(char *tmpfile)
{
FILE *f;
f = fopen(tmpfile, "w");
if (f == NULL)
{
perror("colorize (fopen)");
exit(EXIT_FAILURE);
}
fprintf(f, "%ld\n", (long) getpid());
if (fclose(f) != 0)
{
perror("colorize (fclose)");
exit(EXIT_FAILURE);
}
}
int main(int argc, char **argv)
{
pid_t zshpid = 0;
char *begstr, *endstr;
fd_set rfds;
int ret;
if (argc != 3 && argc != 5)
{
fprintf(stderr,
"Usage: colorize <begstr> <endstr> [ <zshpid> <tmpfile> ]\n");
exit(EXIT_FAILURE);
}
/* Assume that the arguments are correct. Anyway, it is not possible
to check them entirely. */
begstr = argv[1];
endstr = argv[2];
if (argc == 5)
{
/* To do the synchronization with the zsh prompt output...
Seems to be useless in practice, hence the argc == 3 case. */
zshpid = atol(argv[3]);
signal(SIGUSR1, sigusr1);
writepid(argv[4]);
}
fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
/* To watch stdin (fd 0). */
FD_ZERO(&rfds);
FD_SET(0, &rfds);
for (;;)
{
ret = select(1, &rfds, NULL, NULL, NULL);
if (ret < 0 && errno != EINTR)
{
perror("colorize (pselect)");
exit(EXIT_FAILURE);
}
if (ret > 0)
{
static unsigned char buffer[BUFFSIZE];
static int dontcol = 0;
ssize_t n;
while ((n = read(0, buffer, BUFFSIZE)) >= 0)
{
ssize_t i;
if (n == 0)
return 0; /* stdin has been closed */
for (i = 0; i < n; i++)
{
if (buffer[i] == 27)
dontcol = 1;
if (buffer[i] == '\n')
dontcol = 0;
if (!dontcol)
fputs(begstr, stdout);
putchar(buffer[i]);
if (!dontcol)
fputs(endstr, stdout);
}
}
fflush(stdout);
}
if (usr1)
{
usr1 = 0;
if (kill(zshpid, SIGUSR1) != 0)
{
perror("colorize (kill)");
exit(EXIT_FAILURE);
}
}
}
}
|
KHYehor/UniversityPractice
|
C++/LAB2/tasks.h
|
#ifndef tasks_h
#define tasks_h
#include <iostream>
#include <limits.h>
#include <cassert>
#include <cmath>
#include <list>
#include <cstdlib>
#include "ClassTree.h"
using namespace std;
#endif
|
KHYehor/UniversityPractice
|
C++/LAB3/bool:intMethods.h
|
#ifndef bool_intMethods_h
#define bool_intMethods_h
#include <iostream>
#include <vector>
#include "ClassGrapgNode.h"
template<typename T>
int Graph<T>::getSize() { return Size; }
template<typename T>
int Graph<T>::getCountOfRibs()
{
vector<vector<int> *> * matrix = buildMatrixAdjacency();
int ribs = 0;
for (auto i = matrix->begin(); i != matrix->end(); i++) for (auto j = (*i)->begin(); j != (*i)->end(); j++) if (*j == 1) ribs++;
return (ribs / 2 + 1);
}
template<typename T>
int Graph<T>::getStartIndex()
{
int counter = 0;
int index = 0;
vector<vector<int> *> * matrix = buildMatrixAdjacency();
for (auto i = matrix->begin(); i != matrix->end(); i++)
{
int power = 0;
for(auto j = (*i)->begin(); j != (*i)->end(); j++) if (*j == 1) power++;
counter++;
if (power % 2 == 1) index = counter;
}
if (index == 0) return index;
else return (index - 1);
}
template<typename T>
Node<T> * Graph<T>::findNode(T el)
{
for (auto i = LIST.begin(); i != LIST.end(); i++) if ((*i)->data == el) return *i;
return new Node<T>;
}
template<typename T>
vector<vector<int> *> * Graph<T>::buildMatrixAdjacency()
{
vector<vector<int> *> * matrixAdjacency = new vector<vector<int> *>;
for (auto i = LIST.begin(); i != LIST.end(); i++)
{
vector<int> *adjacency = new vector<int>;
for (auto j = LIST.begin(); j != LIST.end(); j++)
{
if (hasElInvector( (*i)->data, (*j)->neighbours) ) adjacency->push_back(1);
else adjacency->push_back(0);
}
matrixAdjacency->push_back(adjacency);
}
return matrixAdjacency;
}
template<typename T>
vector<T> * Graph<T>::getVectorData()
{
vector<T> * data = new vector<T>;
for (auto i = LIST.begin(); i != LIST.end(); i++) data->push_back((*i)->data);
return data;
}
template<typename T>
bool Graph<T>::hasNeighboursList(vector<T> neighbours)
{
int i = 0;
for (auto j = neighbours.begin(); j != neighbours.end(); j++) if (!hasDataInList(*j)) i++;
if (i == neighbours.size()) return true;
else return false;
}
template<typename T>
bool Graph<T>::hasDataInList(T el)
{
for (auto i = LIST.begin(); i != LIST.end(); i++) if ((*i)->data == el) return true;
return false;
}
template<typename T>
bool Graph<T>::hasElInvector(T el, list<Node<T>*> neighbours)
{
for (auto i = neighbours.begin(); i != neighbours.end(); i++) if ((*i)->data == el) return true;
return false;
}
template<typename T>
bool Graph<T>::hasInVector(vector<T> *arr, vector<vector<T> *> * check)
{
for (auto i = check->begin(); i != check->end(); i++) if ((*arr)[0] == (*(*i))[0] && (*arr)[1] == (*(*i))[1]) return true;
return false;
}
template<typename T>
bool Graph<T>::hasSeparates()
{
for (auto i = LIST.begin(); i != LIST.end(); i++) if ((*i)->neighbours.size() == 0) return true;
return false;
}
template<typename T>
bool Graph<T>::hasItRibs(T prevdata, Node<T> * node, vector<vector<T> *> * check)
{
vector<T> * rib = nullptr;
vector<T> * tmp = nullptr;
if (prevdata > node->data) tmp = new vector<T> {node->data, prevdata};
else tmp = new vector<T> {prevdata, node->data};
check->push_back(tmp);
for (auto i = node->neighbours.begin(); i != node->neighbours.end(); i++)
{
if (node->data > (*i)->data) rib = new vector<T> {(*i)->data, node->data};
else rib = new vector<T> {node->data, (*i)->data};
if (!hasInVector(rib, check))
{
check->pop_back();
return true;
}
}
check->pop_back();
return false;
}
template<typename T>
bool Graph<T>::unicalNeighbours(T el, vector<T> *neighbours)
{
for (int i = 0; i < neighbours->size(); i++)
{
for (int j = 0; j < neighbours->size(); j++) if ((*neighbours)[i] == (*neighbours)[j] && i != j) return false;
}
Node<T> *node = findNode(el);
for (auto i = node->neighbours.begin(); i != node->neighbours.end(); i++)
{
for (auto j = neighbours->begin(); j != neighbours->end(); j++)
{
if ((*i)->data == (*j)) return false;
}
}
return true;
}
#endif
|
KHYehor/UniversityPractice
|
C++/LAB3/voidMethods.h
|
#ifndef voidMethods_h
#define voidMethods_h
#include <iostream>
#include <string>
#include "ClassGrapgNode.h"
using namespace std;
template<typename T>
Graph<T>::Graph() { Size = 0; }
template<typename T>
void Graph<T>::addNode(T el)
{
if (hasDataInList(el)) cout << "Graph has already this element." << endl;
else
{
Node<T> *node = new Node<T>;
node->data = el;
LIST.push_back(node);
Size++;
}
}
template<typename T>
void Graph<T>::addNode(T el, vector<T> neighbours)
{
if (hasDataInList(el)) cout << "Graph has already this element." << endl;
else if (!unicalNeighbours(neighbours))
{
Node<T> *node = new Node<T>;
node->data = el;
if (hasNeighboursList(neighbours)) cout << "List does not have the same neighbours." << endl;
else if (!hasNeighboursList(neighbours))
{
LIST.push_back(node);
for (auto i = neighbours.begin(); i != neighbours.end(); i++)
{
Node<T> *Node = findNode(*i);
Node->neighbours.push_back(node);
node->neighbours.push_back(Node);
}
Size++;
}
}
}
template<typename T>
void Graph<T>::connectNode(T el, vector<T> neighbours)
{
if (!hasDataInList(el)) cout << "Graph does not have this element." << endl;
else if (unicalNeighbours(el, &neighbours))
{
if (hasNeighboursList(neighbours)) cout << "List does not have the same neighbours." << endl;
else
{
Node<T> *node = findNode(el);
for (auto i = neighbours.begin(); i != neighbours.end(); i++)
{
Node<T> *Node = findNode(*i);
node->neighbours.push_back(Node);
Node->neighbours.push_back(node);
}
}
}
}
template<typename T>
void Graph<T>::showTable()
{
if (Size == 0) cout << "Graph is clear!" << endl;
else
{
for (auto i = LIST.begin(); i != LIST.end(); i++)
{
cout << (*i)->data << "|";
for (auto j = (*i)->neighbours.begin(); j != (*i)->neighbours.end(); j++) cout << " " << (*j)->data;
cout << "\n";
}
}
}
template<typename T>
void Graph<T>::deleteNode(T el)
{
if (!hasDataInList(el)) cout << "Graph does not have this element." << endl;
else
{
Node<T> *node = findNode(el);
for (auto i = node->neighbours.begin(); i != node->neighbours.end(); i++) (*i)->neighbours.remove(node);
LIST.remove(node);
Size--;
}
}
template<typename T>
void Graph<T>::clear()
{
for (auto i = LIST.begin(); i != LIST.end(); i++) (*i)->neighbours.clear();
for (auto i = LIST.begin(); i != LIST.end(); i++) delete (*i);
Size = 0;
}
template<typename T>
void Graph<T>::showRibs()
{
int EulerRule = 0;
for (auto i = LIST.begin(); i != LIST.end(); i++) if ((*i)->data % 2 != 0) EulerRule++;
if (EulerRule > 2) cout << "Euler cycle is impossible to do." << endl;
else
{
vector<vector<T>> ribs;
for (auto i = LIST.begin(); i != LIST.end(); i++)
{
for (auto j = (*i)->neighbours.begin(); j != (*i)->neighbours.end(); j++)
{
if ((*i)->data < (*j)->data) ribs.push_back(vector<T>{(*i)->data, (*j)->data});
}
}
for (int i = 0; i < ribs.size(); i++) cout << "rib - " << ribs[i][0] << "<--->" << ribs[i][1] << endl;
}
}
template<typename T>
void Graph<T>::showMatrixAdjacency()
{
vector<vector<int> *> * matrix = buildMatrixAdjacency();
for (auto i = matrix->begin(); i != matrix->end(); i++)
{
cout << "[ ";
for (auto j = (*i)->begin(); j != (*i)->end(); j++) cout << (*j) << " ";
cout << "]\n";
}
}
template<typename T>
void Graph<T>::EulerLoop()
{
int counter = 0;
for (auto i = LIST.begin(); i != LIST.end(); i++) if ((*i)->neighbours.size() % 2 == 1) counter++;
if (counter <= 2 && !hasSeparates() && Size != 0) buildEulerLoop();
else cout << "Impossible to build Euler Loop." << endl;
}
template<typename T>
void Graph<T>::buildEulerLoop()
{
Node <T> * startnode = findNode((*getVectorData())[getStartIndex()]);
vector<vector<T> *> * check = new vector<vector<T> *>;
vector<T> * loop = new vector<T>;
vector<int> * rib = nullptr;
loop->push_back(startnode->data);
for (int i = 0; i < getCountOfRibs(); i++)
{
for (auto j = startnode->neighbours.begin(); j != startnode->neighbours.end(); j++)
{
if (startnode->data > (*j)->data) rib = new vector<T> {(*j)->data, startnode->data};
else rib = new vector<T> {startnode->data, (*j)->data};
if (!hasInVector(rib, check) && (hasItRibs(startnode->data, *j, check) || (i + 1) == getCountOfRibs()))
{
loop->push_back((*j)->data);
startnode = *j;
check->push_back(rib);
break;
}
}
}
for (auto i = 0; i < loop->size(); i++)
{
if (i % 20 == 0 && i != 0) cout << "\n--->";
if ((i + 1) == loop->size()) cout << (*loop)[i] << endl;
else cout << (*loop)[i] << "--->";
}
}
#endif
|
KHYehor/UniversityPractice
|
C++/LAB2/methods.h
|
#ifndef methods_h
#define methods_h
#include <iostream>
#include <limits.h>
#include <cassert>
#include <cmath>
#include <list>
#include <queue>
#include "ClassTree.h"
using namespace std;
template<typename T>
BinaryTree<T>::BinaryTree()
{
root = nullptr;
Depth = 0;
Size = 0;
}
template<typename T>
bool BinaryTree<T>::find(T el)
{
if (root == nullptr)
{
cout << "Tree is empty!" << endl;
return false;
}
else
{
Node<T> *node = root;
while (true)
{
if (node->data == el) return true;
else if (node->data > el && node->pleft == nullptr) return false;
else if (node->data < el && node->pright == nullptr) return false;
else if (node->data > el) node = node->pleft;
else if (node->data < el) node = node->pright;
}
}
}
template<typename T>
int BinaryTree<T>::min()
{
Node<T> *node = root;
while (true) if (node->pleft != nullptr) node = node->pleft; else break;
return node->data;
}
template<typename T>
int BinaryTree<T>::max()
{
Node<T> *node = root;
while (true) if (node->pright != nullptr) node = node->pright; else break;
return node->data;
}
template<typename T>
int BinaryTree<T>::getSize() { return Size; }
template<typename T>
int BinaryTree<T>::getMaxDepth() { return Depth; }
#endif
|
KHYehor/UniversityPractice
|
C++/LAB2/voidmethods.h
|
<filename>C++/LAB2/voidmethods.h
#ifndef voidmethods_h
#define voidmethods_h
#include "ClassTree.h"
template<typename T>
void BinaryTree<T>::fixdepth(Node<T> *node)
{
node->depth--;
if (node->pleft != nullptr) fixdepth(node->pleft);
if (node->pright != nullptr) fixdepth(node->pright);
}
template<typename T>
void BinaryTree<T>::fixmaxdepthhelper(Node<T> *node, int *checkdepth)
{
if (*checkdepth <= node->depth) *checkdepth = node->depth;
if (node->pleft != nullptr) fixmaxdepthhelper(node->pleft, checkdepth);
if (node->pright != nullptr) fixmaxdepthhelper(node->pright, checkdepth);
}
template<typename T>
void BinaryTree<T>::fixmaxdepth()
{
Node<T> *node = root;
int *checkdepth = new int(0);
fixmaxdepthhelper(node, checkdepth);
if (*checkdepth < Depth) Depth--;
}
template<typename T>
void BinaryTree<T>::delhelper(Node<T> *node, T el)
{
if (node->data != el)
{
if (node->pleft != nullptr) delhelper(node->pleft, el);
if (node->pright != nullptr) delhelper(node->pright, el);
}
else
{
if (node->pleft == nullptr && node->pright == nullptr && node->parent == nullptr) root = nullptr;
else if (node->pleft == nullptr && node->pright == nullptr)
{
node = node->parent;
if (node->pleft != nullptr && node->pleft->data == el) node->pleft = nullptr;
else node->pright = nullptr;
fixmaxdepth();
}
else if (node->pleft != nullptr && node->pright == nullptr)
{
Node<T> *tmp = node->pleft;
if (node->parent == nullptr)
{
root = node->pleft;
root->parent = nullptr;
} else {
node = node->parent;
if (node->pleft->data == el) node->pleft = tmp;
else node->pright = tmp;
fixdepth(tmp);
fixmaxdepth();
}
}
else if (node->pright != nullptr)
{
Node<T> *temp = node->pright;
while (temp->pleft != nullptr) temp = temp->pleft;
node->data = temp->data;
if (node->pright == temp) node->pright = nullptr;
else
{
temp = temp->parent;
if (temp->pleft->pright == nullptr) temp->pleft = nullptr;
else
{
temp->pleft = temp->pleft->pright;
temp->pleft->parent = nullptr;
temp->pleft->parent = temp;
fixdepth(temp->pleft);
}
fixmaxdepth();
}
}
}
}
template<typename T>
void BinaryTree<T>::delel(T el)
{
Node<T> *node = root;
if (node != nullptr && find(el)) {
delhelper(node, el);
Size--;
}
else if (!find(el)) cout << "Tree does not have this el." << endl;
else if (node == nullptr) cout << "Tree is empty!" << endl;
}
template<typename T>
void BinaryTree<T>::push(T el)
{
if (root == nullptr)
{
root = new Node<T>;
root->data = el;
root->depth = 0;
root->pleft = nullptr;
root->pright = nullptr;
root->parent = nullptr;
Size++;
}
else
{
Node<T> *cur = root;
int checkdepth = 0;
Node<T> *pushed = new Node<T>;
pushed->data = el;
pushed->pleft = nullptr;
pushed->pright = nullptr;
while (true)
{
if (cur->data == el)
{
cout << "Tree has already this " << cur->data << " el." << endl;
break;
}
else if (cur->data > el && cur->pleft == nullptr)
{
pushed->depth = ++checkdepth;
cur->pleft = pushed;
cur->pleft->parent = cur;
if (Depth < checkdepth) Depth = checkdepth;
Size++;
break;
}
else if (cur->data > el)
{
cur = cur->pleft;
checkdepth++;
}
else if (cur->data < el && cur->pright == nullptr)
{
pushed->depth = ++checkdepth;
cur->pright = pushed;
cur->pright->parent = cur;
if (Depth < checkdepth) Depth = checkdepth;
Size++;
break;
}
else if (cur->data < el)
{
cur = cur->pright;
checkdepth++;
}
}
}
}
template<typename T>
void BinaryTree<T>::depthhelper(Node<T> *node, const int depth)
{
if (node->depth == depth) cout << node->data << " ";
if (node->pleft != nullptr) depthhelper(node->pleft, depth);
if (node->pright != nullptr) depthhelper(node->pright, depth);
}
template<typename T>
void BinaryTree<T>::showdepth(const int depth)
{
Node<T> *node = root;
if (node != nullptr) depthhelper(node, depth);
else cout << "Tree is empty!" << endl;
cout << "\n";
}
template<typename T>
void BinaryTree<T>::showTree()
{
if (root == nullptr) cout << "Tree is empty!" << endl;
else
{
cout << "\nTree:\n" << endl;
for (int i = 0; i <= Depth; i++)
{
cout << "\nTree depth: " << i << ".\n"<<endl;
showdepth(i);
}
}
cout << "\nTree size: " << Size << "." << endl;
cout << "Max depth: " << Depth << ".\n" << endl;
}
template<typename T>
void BinaryTree<T>::clearhelper(Node<T> *node)
{
if (node->pleft == nullptr && node->pright == nullptr)
{
if (node->parent == nullptr) root = nullptr;
else
{
int tmp = node->data;
node = node->parent;
if (node->pleft != nullptr && node->pleft->data == tmp) node->pleft = nullptr;
if (node->pright != nullptr && node->pright->data == tmp) node->pright = nullptr;
clearhelper(node);
}
}
else
{
if (node->pleft != nullptr) clearhelper(node->pleft);
if (node->pright != nullptr) clearhelper(node->pright);
}
}
template<typename T>
void BinaryTree<T>::clear()
{
if (root == nullptr) cout << "Tree is empty" << endl;
else
{
Node<T> *node = root;
clearhelper(node);
Depth = 0;
Size = 0;
}
}
template<typename T>
void averagehelper(Node<T> *node, list<T> *list)
{
list->push_back(node->data);
if (node->pleft != nullptr) averagehelper(node->pleft, list);
if (node->pright != nullptr) averagehelper(node->pright, list);
}
template<typename T>
void BinaryTree<T>::average()
{
if (root == nullptr) cout << "Tree is empty!" << endl;
else
{
Node<T> *node = root;
list<T> *list = new std::list<T>;
int result = 0;
averagehelper(node, list);
for (auto i = list->begin(); i != list->end(); i++) result += *i;
push(result/Size);
cout << "\naverage el: " << result/Size << ".\n" << endl;
}
}
#endif
|
KHYehor/UniversityPractice
|
C++/LAB2/ClassTree.h
|
#ifndef ClassTree_h
#define ClassTree_h
template<typename T>
struct Node
{
T data;
int depth;
Node *pleft;
Node *pright;
Node *parent;
};
template<typename T>
class BinaryTree
{
private:
Node<T> *root;
int Depth;
int Size;
void fixdepth(Node<T> *node);
void fixmaxdepth();
void delhelper(Node<T> *node, T el);
void showdepth(int depth);
void clearhelper(Node<T> *node);
void fixmaxdepthhelper(Node<T> *node, int *checkdepth);
void depthhelper(Node<T> *node, const int depth);
public:
BinaryTree();
void push(T el);
void delel(T el);
void showTree();
void clear();
void average();
bool find(T el);
int min();
int max();
int getSize();
int getMaxDepth();
};
#endif
|
KHYehor/UniversityPractice
|
C++/LAB3/ClassGrapgNode.h
|
<reponame>KHYehor/UniversityPractice
#ifndef ClassGrapgNode_h
#define ClassGrapgNode_h
#include <iostream>
#include <list>
using namespace std;
template<typename T>
struct Node
{
T data;
list<Node<T> *> neighbours;
};
template<typename T>
class Graph
{
private:
int Size;
list<Node<T> *> LIST;
void buildEulerLoop();
bool hasItRibs(T prevdata, Node<T> * el, vector<vector<T> *> * check);
bool hasDataInList(T el);
bool hasNeighboursList(vector<T> neighbours);
bool hasElInvector(T el, list<Node<T>*> neighbours);
bool hasInVector(vector<T> *arr, vector<vector<T> *> * check);
bool unicalNeighbours(T el, vector<T> *neighbours);
int getStartIndex();
Node<T> * findNode(T el);
vector<vector<int> *> * buildMatrixAdjacency();
public:
Graph();
void addNode(T el);
void addNode(T el, vector<T> neighbours);
void deleteNode(T el);
void clear();
void connectNode(T el, vector<T> neighbours);
void showTable();
void showMatrixAdjacency();
void EulerLoop();
void showRibs();
int getSize();
int getCountOfRibs();
vector<T> * getVectorData();
bool hasSeparates();
};
#endif
|
KHYehor/UniversityPractice
|
C++/TA3LAB/autoFill.h
|
#ifndef autoFill_h
#define autoFill_h
#include <iostream>
#include <string>
string random_string( size_t length )
{
auto randchar = []() -> char
{
const char charset[] =
"0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
const size_t max_index = (sizeof(charset) - 1);
return charset[ rand() % max_index ];
};
string str(length,0);
generate_n( str.begin(), length, randchar );
return str;
}
#endif
|
KHYehor/UniversityPractice
|
C++/TA3LAB/BTREE.h
|
<reponame>KHYehor/UniversityPractice
#ifndef BTREE_h
#define BTREE_h
#include <iostream>
#include <string>
using namespace std;
const int t=1000;
struct BNode {
string keys[2*t];
string nameOfFile = "";
BNode *children[2*t+1];
BNode *parent;
int count; //количество ключей
int countSons; //количество сыновей
bool leaf;
};
class Tree {
private:
BNode *root;
void insert_to_node(string key, BNode *node);
void sort(BNode *node);
void restruct(BNode *node);
void deletenode(BNode *node);
bool searchKey(string key, BNode *node);
void remove(string key, BNode *node);
void removeFromNode(string key, BNode *node);
void removeLeaf(string key, BNode *node);
void lconnect(BNode *node, BNode *othernode);
void rconnect(BNode *node, BNode *othernode);
void repair(BNode *node);
BNode * searchBNode(string key, BNode *node);
public:
Tree();
~Tree();
void insert(string key);
bool search(string key);
void remove(string key);
BNode * getBNode(string key);
};
Tree::Tree() { root=nullptr; }
Tree::~Tree(){ if(root!=nullptr) deletenode(root); }
void Tree::deletenode(BNode *node){
if (node!=nullptr){
for (int i=0; i<=(2*t-1); i++){
if (node->children[i]!=nullptr) deletenode(node->children[i]);
else {
delete(node);
break;
}
}
}
}
void Tree::insert_to_node(string key, BNode *node){
node->keys[node->count]=key;
node->count=node->count+1;
sort(node);
}
void Tree::sort(BNode *node) {
string m;
for (int i=0; i<(2*t-1); i++){
for (int j=i+1; j<=(2*t-1); j++){
if ((node->keys[i] != "") && (node->keys[j]!="")){
if ((node->keys[i]) > (node->keys[j])){
m=node->keys[i];
node->keys[i]=node->keys[j];
node->keys[j]=m;
}
} else break;
}
}
}
void Tree::insert(string key){
if (root==nullptr) {
BNode *newRoot = new BNode;
newRoot->keys[0]=key;
for(int j=1; j<=(2*t-1); j++) newRoot->keys[j]="";
for (int i=0; i<=(2*t); i++) newRoot->children[i]=nullptr;
newRoot->count=1;
newRoot->countSons=0;
newRoot->leaf=true;
newRoot->parent=nullptr;
root=newRoot;
} else {
BNode *ptr=root;
while (ptr->leaf==false){ //выбор ребенка до тех пор, пока узел не будет являться листом
for (int i=0; i<=(2*t-1); i++){ //перебираем все ключи
if (ptr->keys[i]!="") {
if (key<ptr->keys[i]) {
ptr=ptr->children[i];
break;
}
if ((ptr->keys[i+1]=="")&&(key>ptr->keys[i])) {
ptr=ptr->children[i+1]; //перенаправляем к самому последнему ребенку, если цикл не "сломался"
break;
}
} else break;
}
}
insert_to_node(key, ptr);
while (ptr->count==2*t){
if (ptr==root){
restruct(ptr);
break;
} else {
restruct(ptr);
ptr=ptr->parent;
}
}
}
}
void Tree::restruct(BNode *node){
if (node->count<(2*t-1)) return;
//первый сын
BNode *child1 = new BNode;
int j;
for (j=0; j<=t-2; j++) child1->keys[j]=node->keys[j];
for (j=t-1; j<=(2*t-1); j++) child1->keys[j]="";
child1->count=t-1; //количество ключей в узле
if(node->countSons!=0){
for (int i=0; i<=(t-1); i++){
child1->children[i]=node->children[i];
child1->children[i]->parent=child1;
}
for (int i=t; i<=(2*t); i++) child1->children[i]=nullptr;
child1->leaf=false;
child1->countSons=t-1; //количество сыновей
} else {
child1->leaf=true;
child1->countSons=0;
for (int i=0; i<=(2*t); i++) child1->children[i]=nullptr;
}
//второй сын
BNode *child2 = new BNode;
for (int j=0; j<=(t-1); j++) child2->keys[j]=node->keys[j+t];
for (j=t; j<=(2*t-1); j++) child2->keys[j]="";
child2->count=t; //количество ключей в узле
if(node->countSons!=0) {
for (int i=0; i<=(t); i++){
child2->children[i]=node->children[i+t];
child2->children[i]->parent=child2;
}
for (int i=t+1; i<=(2*t); i++) child2->children[i]=nullptr;
child2->leaf=false;
child2->countSons=t; //количество сыновей
} else {
child2->leaf=true;
child2->countSons=0;
for (int i=0; i<=(2*t); i++) child2->children[i]=nullptr;
}
//родитель
if (node->parent==nullptr){ //если родителя нет, то это корень
node->keys[0]=node->keys[t-1];
for(int j=1; j<=(2*t-1); j++) node->keys[j]="";
node->children[0]=child1;
node->children[1]=child2;
for(int i=2; i<=(2*t); i++) node->children[i]=nullptr;
node->parent=nullptr;
node->leaf=false;
node->count=1;
node->countSons=2;
child1->parent=node;
child2->parent=node;
} else {
insert_to_node(node->keys[t-1], node->parent);
for (int i=0; i<=(2*t); i++){
if (node->parent->children[i]==node) node->parent->children[i]=nullptr;
}
for (int i=0; i<=(2*t); i++){
if (node->parent->children[i]==nullptr) {
for (int j=(2*t); j>(i+1); j--) node->parent->children[j]=node->parent->children[j-1];
node->parent->children[i+1]=child2;
node->parent->children[i]=child1;
break;
}
}
child1->parent=node->parent;
child2->parent=node->parent;
node->parent->leaf=false;
delete node;
}
}
bool Tree::search(string key){
return searchKey(key, this->root);
}
bool Tree::searchKey(string key, BNode *node){
if (node!=nullptr){
if (node->leaf==false){
int i;
for (i=0; i<=(2*t-1); i++){
if (node->keys[i]!="") {
if(key==node->keys[i]) return true;
if ((key<node->keys[i])){
return searchKey(key, node->children[i]);
break;
}
} else break;
}
return searchKey(key, node->children[i]);
} else {
for(int j=0; j<=(2*t-1); j++)
if (key==node->keys[j]) return true;
return false;
}
} else return false;
}
BNode * Tree::searchBNode(string key, BNode *node)
{
if (node!=nullptr){
if (node->leaf==false){
int i;
for (i=0; i<=(2*t-1); i++){
if (node->keys[i]!="") {
if(key==node->keys[i]) return node;
if ((key<node->keys[i])){
return searchBNode(key, node->children[i]);
break;
}
} else break;
}
return searchBNode(key, node->children[i]);
} else {
for(int j=0; j<=(2*t-1); j++)
if (key==node->keys[j]) return node;
return new BNode;
}
} else return new BNode;
}
BNode * Tree::getBNode(string key)
{
return searchBNode(key, this->root);
}
void Tree::removeFromNode(string key, BNode *node){
for (int i=0; i<node->count; i++){
if (node->keys[i]==key){
for (int j=i; j<node->count; j++) {
node->keys[j]=node->keys[j+1];
node->children[j]=node->children[j+1];
}
node->keys[node->count-1]="";
node->children[node->count-1]=node->children[node->count];
node->children[node->count]=nullptr;
break;
}
}
node->count--;
}
void Tree::lconnect(BNode *node, BNode *othernode){
if (node==nullptr) return;
for (int i=0; i<=(othernode->count-1); i++){
node->keys[node->count]=othernode->keys[i];
node->children[node->count]=othernode->children[i];
node->count=node->count+1;
}
node->children[node->count]=othernode->children[othernode->count];
for (int j=0; j<=node->count; j++){
if (node->children[j]==nullptr) break;
node->children[j]->parent=node;
}
delete othernode;
}
void Tree::rconnect(BNode *node, BNode *othernode){
if (node==nullptr) return;
for (int i=0; i<=(othernode->count-1); i++){
node->keys[node->count]=othernode->keys[i];
node->children[node->count+1]=othernode->children[i+1];
node->count=node->count+1;
}
for (int j=0; j<=node->count; j++){
if (node->children[j]==nullptr) break;
node->children[j]->parent=node;
}
delete othernode;
}
void Tree::repair(BNode *node){
if ((node==root)&&(node->count==0)){
if (root->children[0]!=nullptr){
root->children[0]->parent=nullptr;
root=root->children[0];
} else {
delete root;
}
return;
}
BNode *ptr=node;
int k1;
int k2;
int positionSon;
BNode *parent=ptr->parent;
for (int j=0; j<=parent->count; j++){
if (parent->children[j]==ptr){
positionSon=j; //позиция узла по отношению к родителю
break;
}
}
//если ptr-первый ребенок (самый левый)
if (positionSon==0){
insert_to_node(parent->keys[positionSon], ptr);
lconnect(ptr, parent->children[positionSon+1]);
parent->children[positionSon+1]=ptr;
parent->children[positionSon]=nullptr;
removeFromNode(parent->keys[positionSon], parent);
if(ptr->count==2*t){
while (ptr->count==2*t){
if (ptr==root){
restruct(ptr);
break;
} else {
restruct(ptr);
ptr=ptr->parent;
}
}
} else
if (parent->count<=(t-2)) repair(parent);
} else {
//если ptr-последний ребенок (самый правый)
if (positionSon==parent->count){
insert_to_node(parent->keys[positionSon-1], parent->children[positionSon-1]);
lconnect(parent->children[positionSon-1], ptr);
parent->children[positionSon]=parent->children[positionSon-1];
parent->children[positionSon-1]=nullptr;
removeFromNode(parent->keys[positionSon-1], parent);
BNode *temp=parent->children[positionSon];
if(ptr->count==2*t){
while (temp->count==2*t){
if (temp==root){
restruct(temp);
break;
} else {
restruct(temp);
temp=temp->parent;
}
}
} else
if (parent->count<=(t-2)) repair(parent);
} else { //если ptr имеет братьев справа и слева
insert_to_node(parent->keys[positionSon], ptr);
lconnect(ptr, parent->children[positionSon+1]);
parent->children[positionSon+1]=ptr;
parent->children[positionSon]=nullptr;
removeFromNode(parent->keys[positionSon], parent);
if(ptr->count==2*t){
while (ptr->count==2*t){
if (ptr==root){
restruct(ptr);
break;
} else {
restruct(ptr);
ptr=ptr->parent;
}
}
} else
if (parent->count<=(t-2)) repair(parent);
}
}
}
void Tree::removeLeaf(string key, BNode *node){
if ((node==root)&&(node->count==1)){
removeFromNode(key, node);
root->children[0]=nullptr;
delete root;
root=nullptr;
return;
}
if (node==root) {
removeFromNode(key, node);
return;
}
if (node->count>(t-1)) {
removeFromNode(key, node);
return;
}
BNode *ptr=node;
string k1;
string k2;
int position;
int positionSon;
int i;
for (int i=0; i<=node->count-1; i++){
if (key==node->keys[i]) {
position=i; //позиция ключа в узле
break;
}
}
BNode *parent=ptr->parent;
for (int j=0; j<=parent->count; j++){
if (parent->children[j]==ptr){
positionSon=j; //позиция узла по отношению к родителю
break;
}
}
//если ptr-первый ребенок (самый левый)
if (positionSon==0){
if (parent->children[positionSon+1]->count>(t-1)){ //если у правого брата больше, чем t-1 ключей
k1=parent->children[positionSon+1]->keys[0]; //k1 - минимальный ключ правого брата
k2=parent->keys[positionSon]; //k2 - ключ родителя, больше, чем удаляемый, и меньше, чем k1
insert_to_node(k2, ptr);
removeFromNode(key, ptr);
parent->keys[positionSon]=k1; //меняем местами k1 и k2
removeFromNode(k1, parent->children[positionSon+1]); //удаляем k1 из правого брата
} else { //если у правого <u>единственного</u> брата не больше t-1 ключей
removeFromNode(key, ptr);
if (ptr->count<=(t-2)) repair(ptr);
}
} else {
//если ptr-последний ребенок (самый правый)
if (positionSon==parent->count){
//если у левого брата больше, чем t-1 ключей
if (parent->children[positionSon-1]->count>(t-1)){
BNode *temp=parent->children[positionSon-1];
k1=temp->keys[temp->count-1]; //k1 - максимальный ключ левого брата
k2=parent->keys[positionSon-1]; //k2 - ключ родителя, меньше, чем удаляемый и больше, чем k1
insert_to_node(k2, ptr);
removeFromNode(key, ptr);
parent->keys[positionSon-1]=k1;
removeFromNode(k1, temp);
} else { //если у <u>единственного</u> левого брата не больше t-1 ключей
removeFromNode(key, ptr);
if (ptr->count<=(t-2)) repair(ptr);
}
} else { //если ptr имеет братьев справа и слева
//если у правого брата больше, чем t-1 ключей
if (parent->children[positionSon+1]->count>(t-1)){
k1=parent->children[positionSon+1]->keys[0]; //k1 - минимальный ключ правого брата
k2=parent->keys[positionSon]; //k2 - ключ родителя, больше, чем удаляемый и меньше, чем k1
insert_to_node(k2, ptr);
removeFromNode(key, ptr);
parent->keys[positionSon]=k1; //меняем местами k1 и k2
removeFromNode(k1, parent->children[positionSon+1]); //удаляем k1 из правого брата
} else {
//если у левого брата больше, чем t-1 ключей
if (parent->children[positionSon-1]->count>(t-1)){
BNode *temp=parent->children[positionSon-1];
k1=temp->keys[temp->count-1]; //k1 - максимальный ключ левого брата
k2=parent->keys[positionSon-1]; //k2 - ключ родителя, меньше, чем удаляемый и больше, чем k1
insert_to_node(k2, ptr);
removeFromNode(key, ptr);
parent->keys[positionSon-1]=k1;
removeFromNode(k1, temp);
} else { //если у обоих братьев не больше t-1 ключей
removeFromNode(key, ptr);
if (ptr->count<=(t-2)) repair(ptr);
}
}
}
}
}
void Tree::remove(string key, BNode *node){
BNode *ptr=node;
int position; //номер ключа
int i;
for (int i=0; i<=node->count-1; i++){
if (key==node->keys[i]) {
position=i;
break;
}
}
int positionSon; //номер сына по отношению к родителю
if (ptr->parent!=nullptr){
for(int i=0; i<=ptr->parent->count; i++){
if (ptr->children[i]==ptr){
positionSon==i;
break;
}
}
}
//находим наименьший ключ правого поддерева
ptr=ptr->children[position+1];
string newkey=ptr->keys[0];
while (ptr->leaf==false) ptr=ptr->children[0];
//если ключей в найденном листе не больше 1 - ищем наибольший ключ в левом поддереве
//иначе - просто заменяем key на новый ключ, удаляем новый ключ из листа
if (ptr->count>(t-1)) {
newkey=ptr->keys[0];
removeFromNode(newkey, ptr);
node->keys[position]=newkey;
} else {
ptr=node;
//ищем наибольший ключ в левом поддереве
ptr=ptr->children[position];
newkey=ptr->keys[ptr->count-1];
while (ptr->leaf==false) ptr=ptr->children[ptr->count];
newkey=ptr->keys[ptr->count-1];
node->keys[position]=newkey;
if (ptr->count>(t-1)) removeFromNode(newkey, ptr);
else {
//если ключей не больше, чем t-1 - перестраиваем
removeLeaf(newkey, ptr);
}
}
}
void Tree::remove(string key){
BNode *ptr=this->root;
int position;
int positionSon;
int i;
if (searchKey(key, ptr)==false) {
return;
} else {
//ищем узел, в котором находится ключ для удаления
for (i=0; i<=ptr->count-1; i++){
if (ptr->keys[i]!="") {
if(key==ptr->keys[i]) {
position=i;
break;
} else {
if ((key<ptr->keys[i])){
ptr=ptr->children[i];
positionSon=i;
i=-1;
} else {
if (i==(ptr->count-1)) {
ptr=ptr->children[i+1];
positionSon=i+1;
i=-1;
}
}
}
} else break;
}
}
if (ptr->leaf==true) {
if (ptr->count>(t-1)) removeFromNode(key,ptr);
else removeLeaf(key, ptr);
} else remove(key, ptr);
}
#endif
|
KHYehor/UniversityPractice
|
C++/LAB3/EulerLoop.h
|
<filename>C++/LAB3/EulerLoop.h
//
// EulerLoop.h
// LAB3
//
// Created by <NAME> on 27.05.2018.
// Copyright © 2018 <NAME>. All rights reserved.
//
#ifndef EulerLoop_h
#define EulerLoop_h
#endif /* EulerLoop_h */
|
Asmod4n/mruby-lmdb
|
src/mrb_lmdb.c
|
#include "mruby/lmdb.h"
#include "mrb_lmdb.h"
static mrb_value
mrb_fix2bin_le(mrb_state* mrb, mrb_value self)
{
mrb_int number = mrb_integer(self);
mrb_value pp = mrb_str_new(mrb, NULL, sizeof(mrb_int));
unsigned char* p = (unsigned char*)RSTRING_PTR(pp);
#ifdef MRB_INT64
p[0] = (unsigned char)number & 0xFF;
p[1] = (unsigned char)(number >> 8) & 0xFF;
p[2] = (unsigned char)(number >> 16) & 0xFF;
p[3] = (unsigned char)(number >> 24) & 0xFF;
p[4] = (unsigned char)(number >> 32) & 0xFF;
p[5] = (unsigned char)(number >> 40) & 0xFF;
p[6] = (unsigned char)(number >> 48) & 0xFF;
p[7] = (unsigned char)(number >> 56) & 0xFF;
#elif defined(MRB_INT16)
p[0] = (unsigned char)number & 0xFF;
p[1] = (unsigned char)(number >> 8) & 0xFF;
#else
p[0] = (unsigned char)number & 0xFF;
p[1] = (unsigned char)(number >> 8) & 0xFF;
p[2] = (unsigned char)(number >> 16) & 0xFF;
p[3] = (unsigned char)(number >> 24) & 0xFF;
#endif
return pp;
}
static mrb_value
mrb_fix2bin_be(mrb_state* mrb, mrb_value self)
{
mrb_int number = mrb_integer(self);
mrb_value pp = mrb_str_new(mrb, NULL, sizeof(mrb_int));
unsigned char* p = (unsigned char*)RSTRING_PTR(pp);
#ifdef MRB_INT64
p[0] = (unsigned char)(number >> 56) & 0xFF;
p[1] = (unsigned char)(number >> 48) & 0xFF;
p[2] = (unsigned char)(number >> 40) & 0xFF;
p[3] = (unsigned char)(number >> 32) & 0xFF;
p[4] = (unsigned char)(number >> 24) & 0xFF;
p[5] = (unsigned char)(number >> 16) & 0xFF;
p[6] = (unsigned char)(number >> 8) & 0xFF;
p[7] = (unsigned char)number & 0xFF;
#elif defined(MRB_INT16)
p[0] = (unsigned char)(number >> 8) & 0xFF;
p[1] = (unsigned char)number & 0xFF;
#else
p[0] = (unsigned char)(number >> 24) & 0xFF;
p[1] = (unsigned char)(number >> 16) & 0xFF;
p[2] = (unsigned char)(number >> 8) & 0xFF;
p[3] = (unsigned char)number & 0xFF;
#endif
return pp;
}
static mrb_value
mrb_bin2fix_be(mrb_state* mrb, mrb_value self)
{
if (RSTRING_LEN(self) != sizeof(mrb_int)) {
mrb_raise(mrb, E_TYPE_ERROR, "String is not encoded with Integer.to_bin");
}
unsigned char* p = (unsigned char*)RSTRING_PTR(self);
mrb_int number;
#ifdef MRB_INT64
number = (((mrb_int) (p[0])) << 56)
+ (((mrb_int) (p[1])) << 48)
+ (((mrb_int) (p[2])) << 40)
+ (((mrb_int) (p[3])) << 32)
+ (((mrb_int) (p[4])) << 24)
+ (((mrb_int) (p[5])) << 16)
+ (((mrb_int) (p[6])) << 8)
+ (((mrb_int) (p[7])));
#elif defined(MRB_INT16)
number = (((mrb_int)(p[0])) << 8)
+ (((mrb_int)(p[1])));
#else
number = (((mrb_int) (p[0])) << 24)
+ (((mrb_int) (p[1])) << 16)
+ (((mrb_int) (p[2])) << 8)
+ (((mrb_int) (p[3])));
#endif
return mrb_int_value(mrb, number);
}
static mrb_value
mrb_bin2fix_le(mrb_state* mrb, mrb_value self)
{
if (RSTRING_LEN(self) != sizeof(mrb_int)) {
mrb_raise(mrb, E_TYPE_ERROR, "String is not encoded with Integer.to_bin");
}
unsigned char* p = (unsigned char*)RSTRING_PTR(self);
mrb_int number;
#ifdef MRB_INT64
number = (((mrb_int)(p[0])))
+ (((mrb_int)(p[1])) << 8)
+ (((mrb_int)(p[2])) << 16)
+ (((mrb_int)(p[3])) << 24)
+ (((mrb_int)(p[4])) << 32)
+ (((mrb_int)(p[5])) << 40)
+ (((mrb_int)(p[6])) << 48)
+ (((mrb_int)(p[7])) << 56);
#elif defined(MRB_INT16)
number = (((mrb_int)(p[0])))
+ (((mrb_int)(p[1])) << 8);
#else
number = (((mrb_int)(p[0])))
+ (((mrb_int)(p[1])) << 8)
+ (((mrb_int)(p[2])) << 16)
+ (((mrb_int)(p[3])) << 24);
#endif
return mrb_int_value(mrb, number);
}
static void
mrb_mdb_check_error(mrb_state* mrb, const char* func)
{
if (errno != MDB_SUCCESS) {
if (errno >= 0) {
mrb_sys_fail(mrb, func);
} else {
mrb_value error2class = mrb_const_get(mrb, mrb_obj_value(E_LMDB_ERROR), mrb_intern_lit(mrb, "Error2Class"));
struct RClass* errclass = mrb_class_ptr(mrb_hash_get(mrb, error2class, mrb_int_value(mrb, errno)));
mrb_value func_str = mrb_str_new_static(mrb, func, strlen(func));
const char* errstr = mdb_strerror(errno);
mrb_value error_str = mrb_str_new_static(mrb, errstr, strlen(errstr));
mrb_raisef(mrb, errclass, "%S: %S", func_str, error_str);
}
}
}
static mrb_value
mrb_mdb_env_create(mrb_state* mrb, mrb_value self)
{
MDB_env* env;
errno = mdb_env_create(&env);
mrb_mdb_check_error(mrb, "mdb_env_create");
mrb_data_init(self, env, &mdb_env_type);
return self;
}
static mrb_value
mrb_mdb_env_open(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
char* path;
mrb_int flags = 0, mode = 0600;
mrb_get_args(mrb, "z|ii", &path, &flags, &mode);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
if (mode < INT_MIN||mode > INT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "mode is out of range");
}
errno = mdb_env_open(env, (const char*)path,
(unsigned int)flags, (mdb_mode_t)mode);
mrb_mdb_check_error(mrb, "mdb_env_open");
return self;
}
static mrb_value
mrb_mdb_env_copy(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
char* path;
mrb_get_args(mrb, "z", &path);
errno = mdb_env_copy(env, (const char*)path);
mrb_mdb_check_error(mrb, "mdb_env_copy");
return self;
}
static mrb_value
mrb_mdb_env_copy2(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
char* path;
mrb_int flags = 0;
mrb_get_args(mrb, "z|i", &path, &flags);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
errno = mdb_env_copy2(env, (const char*)path, (unsigned int)flags);
mrb_mdb_check_error(mrb, "mdb_env_copy2");
return self;
}
static mrb_value
mrb_mdb_env_stat(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
MDB_stat stat;
mrb_value args[6];
errno = mdb_env_stat(env, &stat);
mrb_mdb_check_error(mrb, "mdb_env_stat");
args[0] = mrb_int_value(mrb, stat.ms_psize);
args[1] = mrb_int_value(mrb, stat.ms_depth);
args[2] = mrb_int_value(mrb, stat.ms_branch_pages);
args[3] = mrb_int_value(mrb, stat.ms_leaf_pages);
args[4] = mrb_int_value(mrb, stat.ms_overflow_pages);
args[5] = mrb_int_value(mrb, stat.ms_entries);
return mrb_obj_new(mrb, LMDB_STAT, sizeof(args) / sizeof(args[0]), args);
}
static mrb_value
mrb_mdb_env_info(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
MDB_envinfo stat;
mrb_value args[6];
errno = mdb_env_info(env, &stat);
mrb_mdb_check_error(mrb, "mdb_env_info");
args[0] = stat.me_mapaddr ? mrb_cptr_value(mrb, stat.me_mapaddr) : mrb_nil_value();
args[1] = mrb_int_value(mrb, stat.me_mapsize);
args[2] = mrb_int_value(mrb, stat.me_last_pgno);
args[3] = mrb_int_value(mrb, stat.me_last_txnid);
args[4] = mrb_int_value(mrb, stat.me_maxreaders);
args[5] = mrb_int_value(mrb, stat.me_numreaders);
return mrb_obj_new(mrb, LMDB_ENV_INFO, sizeof(args) / sizeof(args[0]), args);
}
static mrb_value
mrb_mdb_env_sync(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
mrb_bool force = FALSE;
mrb_get_args(mrb, "|b", &force);
errno = mdb_env_sync(env, (int)force);
mrb_mdb_check_error(mrb, "mdb_env_sync");
return self;
}
static mrb_value
mrb_mdb_env_close(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
if (env) {
mdb_env_close(env);
mrb_data_init(self, NULL, NULL);
return mrb_true_value();
}
return mrb_false_value();
}
static mrb_value
mrb_mdb_env_set_flags(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
mrb_int flags = 0;
mrb_bool onoff = TRUE;
mrb_get_args(mrb, "|ib", &flags, &onoff);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
errno = mdb_env_set_flags(env, (unsigned int)flags, (int)onoff);
mrb_mdb_check_error(mrb, "mdb_env_set_flags");
return self;
}
static mrb_value
mrb_mdb_env_get_flags(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
unsigned int flags;
errno = mdb_env_get_flags(env, &flags);
mrb_mdb_check_error(mrb, "mdb_env_get_flags");
return mrb_int_value(mrb, flags);
}
static mrb_value
mrb_mdb_env_get_path(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
const char* path;
errno = mdb_env_get_path(env, &path);
mrb_mdb_check_error(mrb, "mdb_env_get_path");
return mrb_str_new_static(mrb, path, strlen(path));
}
static mrb_value
mrb_mdb_env_set_mapsize(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
mrb_float size;
mrb_get_args(mrb, "f", &size);
if (size < 0||size > SIZE_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "size is out of range");
}
errno = mdb_env_set_mapsize(env, (size_t)size);
mrb_mdb_check_error(mrb, "mdb_env_set_mapsize");
return self;
}
static mrb_value
mrb_mdb_env_set_maxreaders(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
mrb_int readers;
mrb_get_args(mrb, "i", &readers);
if (readers < 0||readers > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "readers are out of range");
}
errno = mdb_env_set_maxreaders(env, (unsigned int)readers);
mrb_mdb_check_error(mrb, "mdb_env_set_maxreaders");
return self;
}
static mrb_value
mrb_mdb_env_get_maxreaders(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
unsigned int readers;
errno = mdb_env_get_maxreaders(env, &readers);
mrb_mdb_check_error(mrb, "mdb_env_get_maxreaders");
return mrb_int_value(mrb, readers);
}
static mrb_value
mrb_mdb_env_set_maxdbs(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
mrb_int dbs;
mrb_get_args(mrb, "i", &dbs);
if (dbs < 0||dbs > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbs is out of range");
}
errno = mdb_env_set_maxdbs(env, (MDB_dbi)dbs);
mrb_mdb_check_error(mrb, "mdb_env_set_maxdbs");
return self;
}
static mrb_value
mrb_mdb_env_get_maxkeysize(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
return mrb_int_value(mrb, mdb_env_get_maxkeysize(env));
}
static mrb_value
mrb_mdb_reader_check(mrb_state* mrb, mrb_value self)
{
MDB_env* env = (MDB_env*)DATA_PTR(self);
mrb_assert(env);
int dead;
errno = mdb_reader_check(env, &dead);
mrb_mdb_check_error(mrb, "mdb_reader_check");
return mrb_int_value(mrb, dead);
}
static mrb_value
mrb_mdb_txn_begin(mrb_state* mrb, mrb_value self)
{
MDB_env* env;
mrb_int flags = 0;
MDB_txn* parent = NULL;
MDB_txn* txn;
mrb_get_args(mrb, "d|id!", &env, &mdb_env_type, &flags, &parent, &mdb_txn_type);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
errno = mdb_txn_begin(env, parent, (unsigned int)flags, &txn);
mrb_mdb_check_error(mrb, "mdb_txn_begin");
mrb_data_init(self, txn, &mdb_txn_type);
return self;
}
static mrb_value
mrb_mdb_txn_commit(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn = (MDB_txn*)DATA_PTR(self);
mrb_assert(txn);
errno = mdb_txn_commit(txn);
mrb_data_init(self, NULL, NULL);
mrb_mdb_check_error(mrb, "mdb_txn_commit");
return mrb_true_value();
}
static mrb_value
mrb_mdb_txn_abort(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn = (MDB_txn*)DATA_PTR(self);
if (txn) {
mdb_txn_abort(txn);
mrb_data_init(self, NULL, NULL);
return mrb_true_value();
}
return mrb_false_value();
}
static mrb_value
mrb_mdb_txn_reset(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn = (MDB_txn*)DATA_PTR(self);
mrb_assert(txn);
mdb_txn_reset(txn);
return self;
}
static mrb_value
mrb_mdb_txn_renew(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn = (MDB_txn*)DATA_PTR(self);
mrb_assert(txn);
errno = mdb_txn_renew(txn);
mrb_mdb_check_error(mrb, "mdb_txn_renew");
return self;
}
static mrb_value
mrb_mdb_dbi_open(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int flags = 0;
char* name = NULL;
MDB_dbi dbi;
mrb_get_args(mrb, "d|iz!", &txn, &mdb_txn_type, &flags, &name);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
errno = mdb_dbi_open(txn, (const char*)name, (unsigned int)flags, &dbi);
mrb_mdb_check_error(mrb, "mdb_dbi_open");
return mrb_int_value(mrb, dbi);
}
static mrb_value
mrb_mdb_dbi_flags(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
unsigned int flags;
mrb_get_args(mrb, "di", &txn, &mdb_txn_type, &dbi);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
errno = mdb_dbi_flags(txn, (MDB_dbi)dbi, &flags);
mrb_mdb_check_error(mrb, "mdb_dbi_flags");
return mrb_int_value(mrb, flags);
}
static mrb_value
mrb_mdb_stat(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
MDB_stat stat;
mrb_value args[6];
mrb_get_args(mrb, "di", &txn, &mdb_txn_type, &dbi);
if (dbi < 0||dbi > UINT_MAX)
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
errno = mdb_stat(txn, (MDB_dbi)dbi, &stat);
mrb_mdb_check_error(mrb, "mdb_stat");
args[0] = mrb_int_value(mrb, stat.ms_psize);
args[1] = mrb_int_value(mrb, stat.ms_depth);
args[2] = mrb_int_value(mrb, stat.ms_branch_pages);
args[3] = mrb_int_value(mrb, stat.ms_leaf_pages);
args[4] = mrb_int_value(mrb, stat.ms_overflow_pages);
args[5] = mrb_int_value(mrb, stat.ms_entries);
return mrb_obj_new(mrb, LMDB_STAT, sizeof(args) / sizeof(args[0]), args);
}
static mrb_value
mrb_mdb_drop(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
mrb_bool del = FALSE;
mrb_get_args(mrb, "di|b", &txn, &mdb_txn_type, &dbi, &del);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
errno = mdb_drop(txn, (MDB_dbi)dbi, (int)del);
mrb_mdb_check_error(mrb, "mdb_drop");
return self;
}
static mrb_value
mrb_mdb_get(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
mrb_value key_obj;
mrb_bool static_string = FALSE;
MDB_val key, data;
mrb_get_args(mrb, "dio|b", &txn, &mdb_txn_type, &dbi, &key_obj, &static_string);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
key_obj = mrb_str_to_str(mrb, key_obj);
key.mv_size = RSTRING_LEN(key_obj);
key.mv_data = RSTRING_PTR(key_obj);
errno = mdb_get(txn, (MDB_dbi)dbi, &key, &data);
if (errno == MDB_SUCCESS) {
if (static_string) {
return mrb_str_new_static(mrb, (const char*)data.mv_data, data.mv_size);
} else {
return mrb_str_new(mrb, (const char*)data.mv_data, data.mv_size);
}
}
else if (errno == MDB_NOTFOUND) {
return mrb_nil_value();
} else {
mrb_mdb_check_error(mrb, "mdb_get");
}
return self;
}
static mrb_value
mrb_mdb_put(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
mrb_value key_obj, data_obj;
mrb_int flags = 0;
MDB_val key, data;
mrb_get_args(mrb, "dioo|i", &txn, &mdb_txn_type, &dbi, &key_obj, &data_obj, &flags);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
key_obj = mrb_str_to_str(mrb, key_obj);
key.mv_size = RSTRING_LEN(key_obj);
key.mv_data = RSTRING_PTR(key_obj);
data_obj = mrb_str_to_str(mrb, data_obj);
data.mv_size = RSTRING_LEN(data_obj);
data.mv_data = RSTRING_PTR(data_obj);
errno = mdb_put(txn, (MDB_dbi)dbi, &key, &data, (unsigned int)flags);
mrb_mdb_check_error(mrb, "mdb_put");
return self;
}
static mrb_value
mrb_mdb_del(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
mrb_value key_obj, data_obj = mrb_nil_value();
MDB_val key, data;
mrb_get_args(mrb, "dio|o", &txn, &mdb_txn_type, &dbi, &key_obj, &data_obj);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
key_obj = mrb_str_to_str(mrb, key_obj);
key.mv_size = RSTRING_LEN(key_obj);
key.mv_data = RSTRING_PTR(key_obj);
if (mrb_test(data_obj)) {
data_obj = mrb_str_to_str(mrb, data_obj);
data.mv_size = RSTRING_LEN(data_obj);
data.mv_data = RSTRING_PTR(data_obj);
} else {
data.mv_size = 0;
data.mv_data = NULL;
}
errno = mdb_del(txn, (MDB_dbi)dbi, &key, &data);
if (errno == MDB_SUCCESS) {
return mrb_true_value();
}
else if (errno == MDB_NOTFOUND) {
return mrb_nil_value();
} else {
mrb_mdb_check_error(mrb, "mdb_del");
}
return self;
}
static mrb_value
mrb_mdb_cursor_open(mrb_state* mrb, mrb_value self)
{
MDB_txn* txn;
mrb_int dbi;
MDB_cursor* cursor;
mrb_get_args(mrb, "di", &txn, &mdb_txn_type, &dbi);
if (dbi < 0||dbi > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "dbi is out of range");
}
errno = mdb_cursor_open(txn, (MDB_dbi)dbi, &cursor);
mrb_mdb_check_error(mrb, "mdb_cursor_open");
mrb_data_init(self, cursor, &mdb_cursor_type);
return self;
}
static mrb_value
mrb_mdb_cursor_renew(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
mrb_assert(cursor);
MDB_txn* txn;
mrb_get_args(mrb, "d", &txn, &mdb_txn_type);
errno = mdb_cursor_renew(txn, cursor);
mrb_mdb_check_error(mrb, "mdb_cursor_renew");
return self;
}
static mrb_value
mrb_mdb_cursor_close(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
if (cursor) {
mdb_cursor_close(cursor);
mrb_data_init(self, NULL, NULL);
return mrb_true_value();
}
return mrb_false_value();
}
static mrb_value
mrb_mdb_cursor_get(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
mrb_assert(cursor);
mrb_int cursor_op;
mrb_value key_obj = mrb_nil_value(), data_obj = mrb_nil_value();
mrb_bool static_string = FALSE;
MDB_val key, data;
mrb_get_args(mrb, "i|oob", &cursor_op, &key_obj, &data_obj, &static_string);
if (mrb_test(key_obj)) {
key_obj = mrb_str_to_str(mrb, key_obj);
key.mv_size = RSTRING_LEN(key_obj);
key.mv_data = RSTRING_PTR(key_obj);
} else {
key.mv_size = 0;
key.mv_data = NULL;
}
if (mrb_test(data_obj)) {
data_obj = mrb_str_to_str(mrb, data_obj);
data.mv_size = RSTRING_LEN(data_obj);
data.mv_data = RSTRING_PTR(data_obj);
} else {
data.mv_size = 0;
data.mv_data = NULL;
}
errno = mdb_cursor_get(cursor, &key, &data, cursor_op);
if (errno == MDB_SUCCESS) {
if (static_string) {
key_obj = mrb_str_new_static(mrb, (const char*)key.mv_data, key.mv_size);
data_obj = mrb_str_new_static(mrb, (const char*)data.mv_data, data.mv_size);
} else {
key_obj = mrb_str_new(mrb, (const char*)key.mv_data, key.mv_size);
data_obj = mrb_str_new(mrb, (const char*)data.mv_data, data.mv_size);
}
return mrb_assoc_new(mrb, key_obj, data_obj);
}
else if (errno == MDB_NOTFOUND) {
return mrb_nil_value();
} else {
mrb_mdb_check_error(mrb, "mdb_cursor_get");
}
return self;
}
static mrb_value
mrb_mdb_cursor_put(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
mrb_assert(cursor);
mrb_value key_obj, data_obj;
mrb_int flags = 0;
MDB_val key, data;
mrb_get_args(mrb, "oo|i", &key_obj, &data_obj, &flags);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
key_obj = mrb_str_to_str(mrb, key_obj);
key.mv_size = RSTRING_LEN(key_obj);
key.mv_data = RSTRING_PTR(key_obj);
data_obj = mrb_str_to_str(mrb, data_obj);
data.mv_size = RSTRING_LEN(data_obj);
data.mv_data = RSTRING_PTR(data_obj);
errno = mdb_cursor_put(cursor, &key, &data, (unsigned int)flags);
mrb_mdb_check_error(mrb, "mdb_cursor_put");
return self;
}
static mrb_value
mrb_mdb_cursor_del(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
mrb_assert(cursor);
mrb_int flags = 0;
mrb_get_args(mrb, "|i", &flags);
if (flags < 0||flags > UINT_MAX) {
mrb_raise(mrb, E_RANGE_ERROR, "flags are out of range");
}
errno = mdb_cursor_del(cursor, (unsigned int)flags);
mrb_mdb_check_error(mrb, "mdb_cursor_del");
return self;
}
static mrb_value
mrb_mdb_cursor_count(mrb_state* mrb, mrb_value self)
{
MDB_cursor* cursor = (MDB_cursor*)DATA_PTR(self);
mrb_assert(cursor);
size_t count;
errno = mdb_cursor_count(cursor, &count);
mrb_mdb_check_error(mrb, "mdb_cursor_count");
return mrb_int_value(mrb, count);
}
void
mrb_mruby_lmdb_gem_init(mrb_state* mrb)
{
struct RClass *mdb_mod, *mdb_error, *mdb_env_class, *mdb_txn_class, *mdb_dbi_mod, *mdb_cursor_class;
#ifdef MRB_ENDIAN_BIG
mrb_define_method(mrb, mrb->string_class, "to_fix", mrb_bin2fix_be, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->integer_class, "to_bin", mrb_fix2bin_be, MRB_ARGS_NONE());
#else
mrb_define_method(mrb, mrb->string_class, "to_fix", mrb_bin2fix_le, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->integer_class, "to_bin", mrb_fix2bin_le, MRB_ARGS_NONE());
#endif
mdb_mod = mrb_define_module(mrb, "MDB");
mrb_define_const(mrb, mdb_mod, "VERSION", mrb_str_new_lit(mrb, MDB_VERSION_STRING));
mrb_define_const(mrb, mdb_mod, "FIXEDMAP", mrb_int_value(mrb, MDB_FIXEDMAP));
mrb_define_const(mrb, mdb_mod, "NOSUBDIR", mrb_int_value(mrb, MDB_NOSUBDIR));
mrb_define_const(mrb, mdb_mod, "NOSYNC", mrb_int_value(mrb, MDB_NOSYNC));
mrb_define_const(mrb, mdb_mod, "RDONLY", mrb_int_value(mrb, MDB_RDONLY));
mrb_define_const(mrb, mdb_mod, "NOMETASYNC", mrb_int_value(mrb, MDB_NOMETASYNC));
mrb_define_const(mrb, mdb_mod, "WRITEMAP", mrb_int_value(mrb, MDB_WRITEMAP));
mrb_define_const(mrb, mdb_mod, "MAPASYNC", mrb_int_value(mrb, MDB_MAPASYNC));
mrb_define_const(mrb, mdb_mod, "NOTLS", mrb_int_value(mrb, MDB_NOTLS));
mrb_define_const(mrb, mdb_mod, "NOLOCK", mrb_int_value(mrb, MDB_NOLOCK));
mrb_define_const(mrb, mdb_mod, "NORDAHEAD", mrb_int_value(mrb, MDB_NORDAHEAD));
mrb_define_const(mrb, mdb_mod, "NOMEMINIT", mrb_int_value(mrb, MDB_NOMEMINIT));
mrb_define_const(mrb, mdb_mod, "REVERSEKEY", mrb_int_value(mrb, MDB_REVERSEKEY));
mrb_define_const(mrb, mdb_mod, "DUPSORT", mrb_int_value(mrb, MDB_DUPSORT));
mrb_define_const(mrb, mdb_mod, "INTEGERKEY", mrb_int_value(mrb, MDB_INTEGERKEY));
mrb_define_const(mrb, mdb_mod, "DUPFIXED", mrb_int_value(mrb, MDB_DUPFIXED));
mrb_define_const(mrb, mdb_mod, "INTEGERDUP", mrb_int_value(mrb, MDB_INTEGERDUP));
mrb_define_const(mrb, mdb_mod, "REVERSEDUP", mrb_int_value(mrb, MDB_REVERSEDUP));
mrb_define_const(mrb, mdb_mod, "CREATE", mrb_int_value(mrb, MDB_CREATE));
mrb_define_const(mrb, mdb_mod, "NOOVERWRITE", mrb_int_value(mrb, MDB_NOOVERWRITE));
mrb_define_const(mrb, mdb_mod, "NODUPDATA", mrb_int_value(mrb, MDB_NODUPDATA));
mrb_define_const(mrb, mdb_mod, "CURRENT", mrb_int_value(mrb, MDB_CURRENT));
mrb_define_const(mrb, mdb_mod, "RESERVE", mrb_int_value(mrb, MDB_RESERVE));
mrb_define_const(mrb, mdb_mod, "APPEND", mrb_int_value(mrb, MDB_APPEND));
mrb_define_const(mrb, mdb_mod, "APPENDDUP", mrb_int_value(mrb, MDB_APPENDDUP));
mrb_define_const(mrb, mdb_mod, "MULTIPLE", mrb_int_value(mrb, MDB_MULTIPLE));
mrb_define_const(mrb, mdb_mod, "CP_COMPACT", mrb_int_value(mrb, MDB_CP_COMPACT));
mdb_error = mrb_define_class_under(mrb, mdb_mod, "Error", E_RUNTIME_ERROR);
mdb_env_class = mrb_define_class_under(mrb, mdb_mod, "Env", mrb->object_class);
MRB_SET_INSTANCE_TT(mdb_env_class, MRB_TT_DATA);
mrb_define_method(mrb, mdb_env_class, "initialize", mrb_mdb_env_create, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "open", mrb_mdb_env_open, MRB_ARGS_ARG(1, 2));
mrb_define_method(mrb, mdb_env_class, "copy", mrb_mdb_env_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mdb_env_class, "copy2", mrb_mdb_env_copy2, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, mdb_env_class, "stat", mrb_mdb_env_stat, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "info", mrb_mdb_env_info, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "sync", mrb_mdb_env_sync, MRB_ARGS_OPT(1));
mrb_define_method(mrb, mdb_env_class, "close", mrb_mdb_env_close, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "set_flags", mrb_mdb_env_set_flags, MRB_ARGS_OPT(2));
mrb_define_method(mrb, mdb_env_class, "flags", mrb_mdb_env_get_flags, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "path", mrb_mdb_env_get_path, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "mapsize=", mrb_mdb_env_set_mapsize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mdb_env_class, "maxreaders=", mrb_mdb_env_set_maxreaders, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mdb_env_class, "maxreaders", mrb_mdb_env_get_maxreaders, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "maxdbs=", mrb_mdb_env_set_maxdbs, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mdb_env_class, "maxkeysize", mrb_mdb_env_get_maxkeysize, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_env_class, "reader_check", mrb_mdb_reader_check, MRB_ARGS_NONE());
mdb_txn_class = mrb_define_class_under(mrb, mdb_mod, "Txn", mrb->object_class);
MRB_SET_INSTANCE_TT(mdb_txn_class, MRB_TT_DATA);
mrb_define_method(mrb, mdb_txn_class, "initialize", mrb_mdb_txn_begin, MRB_ARGS_ARG(1, 2));
mrb_define_method(mrb, mdb_txn_class, "commit", mrb_mdb_txn_commit, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_txn_class, "abort", mrb_mdb_txn_abort, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_txn_class, "reset", mrb_mdb_txn_reset, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_txn_class, "renew", mrb_mdb_txn_renew, MRB_ARGS_NONE());
mdb_dbi_mod = mrb_define_module_under(mrb, mdb_mod, "Dbi");
mrb_define_module_function(mrb, mdb_dbi_mod, "open", mrb_mdb_dbi_open, MRB_ARGS_ARG(1, 2));
mrb_define_module_function(mrb, mdb_dbi_mod, "flags", mrb_mdb_dbi_flags, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mdb_mod, "stat", mrb_mdb_stat, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mdb_mod, "get", mrb_mdb_get, MRB_ARGS_ARG(3, 1));
mrb_define_module_function(mrb, mdb_mod, "put", mrb_mdb_put, MRB_ARGS_ARG(4, 1));
mrb_define_module_function(mrb, mdb_mod, "del", mrb_mdb_del, MRB_ARGS_ARG(3, 1));
mrb_define_module_function(mrb, mdb_mod, "drop", mrb_mdb_drop, MRB_ARGS_ARG(2, 1));
mdb_cursor_class = mrb_define_class_under(mrb, mdb_mod, "Cursor", mrb->object_class);
MRB_SET_INSTANCE_TT(mdb_cursor_class, MRB_TT_DATA);
mrb_define_const(mrb, mdb_cursor_class, "FIRST", mrb_int_value(mrb, MDB_FIRST));
mrb_define_const(mrb, mdb_cursor_class, "FIRST_DUP", mrb_int_value(mrb, MDB_FIRST_DUP));
mrb_define_const(mrb, mdb_cursor_class, "GET_BOTH", mrb_int_value(mrb, MDB_GET_BOTH));
mrb_define_const(mrb, mdb_cursor_class, "GET_BOTH_RANGE", mrb_int_value(mrb, MDB_GET_BOTH_RANGE));
mrb_define_const(mrb, mdb_cursor_class, "GET_CURRENT", mrb_int_value(mrb, MDB_GET_CURRENT));
mrb_define_const(mrb, mdb_cursor_class, "GET_MULTIPLE", mrb_int_value(mrb, MDB_GET_MULTIPLE));
mrb_define_const(mrb, mdb_cursor_class, "LAST", mrb_int_value(mrb, MDB_LAST));
mrb_define_const(mrb, mdb_cursor_class, "LAST_DUP", mrb_int_value(mrb, MDB_LAST_DUP));
mrb_define_const(mrb, mdb_cursor_class, "NEXT", mrb_int_value(mrb, MDB_NEXT));
mrb_define_const(mrb, mdb_cursor_class, "NEXT_DUP", mrb_int_value(mrb, MDB_NEXT_DUP));
mrb_define_const(mrb, mdb_cursor_class, "NEXT_MULTIPLE", mrb_int_value(mrb, MDB_NEXT_MULTIPLE));
mrb_define_const(mrb, mdb_cursor_class, "NEXT_NODUP", mrb_int_value(mrb, MDB_NEXT_NODUP));
mrb_define_const(mrb, mdb_cursor_class, "PREV", mrb_int_value(mrb, MDB_PREV));
mrb_define_const(mrb, mdb_cursor_class, "PREV_DUP", mrb_int_value(mrb, MDB_PREV_DUP));
mrb_define_const(mrb, mdb_cursor_class, "PREV_NODUP", mrb_int_value(mrb, MDB_PREV_NODUP));
mrb_define_const(mrb, mdb_cursor_class, "SET", mrb_int_value(mrb, MDB_SET));
mrb_define_const(mrb, mdb_cursor_class, "SET_KEY", mrb_int_value(mrb, MDB_SET_KEY));
mrb_define_const(mrb, mdb_cursor_class, "SET_RANGE", mrb_int_value(mrb, MDB_SET_RANGE));
#ifdef MDB_PREV_MULTIPLE
mrb_define_const(mrb, mdb_cursor_class, "PREV_MULTIPLE", mrb_int_value(mrb, MDB_PREV_MULTIPLE));
#endif
mrb_define_method(mrb, mdb_cursor_class, "initialize", mrb_mdb_cursor_open, MRB_ARGS_REQ(2));
mrb_define_method(mrb, mdb_cursor_class, "renew", mrb_mdb_cursor_renew, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mdb_cursor_class, "close", mrb_mdb_cursor_close, MRB_ARGS_NONE());
mrb_define_method(mrb, mdb_cursor_class, "get", mrb_mdb_cursor_get, MRB_ARGS_ARG(1, 3));
mrb_define_method(mrb, mdb_cursor_class, "put", mrb_mdb_cursor_put, MRB_ARGS_ARG(2, 1));
mrb_define_method(mrb, mdb_cursor_class, "del", mrb_mdb_cursor_del, MRB_ARGS_OPT(1));
mrb_define_method(mrb, mdb_cursor_class, "count", mrb_mdb_cursor_count, MRB_ARGS_NONE());
mrb_value error2class = mrb_hash_new(mrb);
mrb_define_const(mrb, mdb_error, "Error2Class", error2class);
#define mrb_lmdb_define_error(MDB_ERROR, RB_CLASS_NAME) \
do { \
int ai = mrb_gc_arena_save(mrb); \
struct RClass *err = mrb_define_class_under(mrb, mdb_mod, RB_CLASS_NAME, mdb_error); \
mrb_hash_set(mrb, error2class, mrb_int_value(mrb, MDB_ERROR), mrb_obj_value(err)); \
mrb_gc_arena_restore(mrb, ai); \
} while(0)
#include "known_errors_def.cstub"
mrb_value cursor_ops = mrb_hash_new(mrb);
mrb_define_const(mrb, mdb_cursor_class, "Ops", cursor_ops);
#define mrb_lmdb_define_cursor_op(MDB_CURSOR_OP, RB_CURSOR_OP_SYM) \
do { \
int ai = mrb_gc_arena_save(mrb); \
mrb_hash_set(mrb, cursor_ops, mrb_symbol_value(mrb_intern_lit(mrb, RB_CURSOR_OP_SYM)), mrb_int_value(mrb, MDB_CURSOR_OP)); \
mrb_gc_arena_restore(mrb, ai); \
} while(0)
#include "known_cursor_ops_def.cstub"
}
void mrb_mruby_lmdb_gem_final(mrb_state* mrb) {}
|
Asmod4n/mruby-lmdb
|
include/mruby/lmdb.h
|
<gh_stars>10-100
#ifndef MRUBY_LMDB_H
#define MRUBY_LMDB_H
#include <mruby.h>
#ifdef MRB_INT16
# error MRB_INT16 is too small for mruby-lmdb.
#endif
MRB_BEGIN_DECL
#define E_LMDB_ERROR (mrb_class_get_under(mrb, mrb_module_get(mrb, "MDB"), "Error"))
MRB_END_DECL
#endif
|
Asmod4n/mruby-lmdb
|
src/mrb_lmdb.h
|
<reponame>Asmod4n/mruby-lmdb<gh_stars>10-100
#ifndef MRB_LMDB_H
#define MRB_LMDB_H
#include <stdint.h>
#include "lmdb.h"
#include <string.h>
#include <mruby.h>
#include <mruby/data.h>
#include <mruby/class.h>
#include <mruby/string.h>
#include <mruby/array.h>
#include <mruby/dump.h>
#include <errno.h>
#include <mruby/error.h>
#include <mruby/hash.h>
#include <mruby/variable.h>
#define LMDB_STAT (mrb_class_get_under(mrb, mrb_module_get(mrb, "MDB"), "Stat"))
#define LMDB_ENV_INFO (mrb_class_get_under(mrb, mrb_class_get_under(mrb, mrb_module_get(mrb, "MDB"), "Env"), "Info"))
static void
mrb_mdb_env_free(mrb_state* mrb, void* p)
{
mdb_env_close((MDB_env*)p);
}
static const struct mrb_data_type mdb_env_type = {
"$mrb_i_mdb_env", mrb_mdb_env_free,
};
static void
mrb_mdb_txn_free(mrb_state* mrb, void* p)
{
mdb_txn_abort((MDB_txn*)p);
}
static const struct mrb_data_type mdb_txn_type = {
"$mrb_i_mdb_txn", mrb_mdb_txn_free,
};
static void
mrb_mdb_cursor_free(mrb_state* mrb, void* p)
{
mdb_cursor_close((MDB_cursor*)p);
}
static const struct mrb_data_type mdb_cursor_type = {
"$mrb_i_mdb_cursor", mrb_mdb_cursor_free,
};
#endif
|
jessie-murray/webdis
|
src/server.h
|
#ifndef SERVER_H
#define SERVER_H
#include <event.h>
#include <pthread.h>
#include <hiredis/async.h>
#ifdef HAVE_SSL
#include <hiredis/hiredis.h>
#include <hiredis/hiredis_ssl.h>
#endif
struct worker;
struct conf;
struct server {
int fd;
struct event ev;
struct event_base *base;
struct conf *cfg;
#ifdef HAVE_SSL
/* SSL context & error code */
redisSSLContext *ssl_context;
redisSSLContextError ssl_error;
#endif
/* worker threads */
struct worker **w;
int next_worker;
/* log lock */
struct {
pid_t self;
int fd;
struct timeval fsync_tv;
struct event *fsync_ev;
} log;
/* used to log auth message only once */
pthread_mutex_t auth_log_mutex;
int auth_logged;
};
struct server *
server_new(const char *cfg_file);
int
server_start(struct server *s);
#endif
|
jessie-murray/webdis
|
src/conf.h
|
<gh_stars>1000+
#ifndef CONF_H
#define CONF_H
#include <sys/types.h>
#include "slog.h"
struct auth {
/* 1 if only password is used, 0 for username + password */
int use_legacy_auth;
char *username;
char *password;
};
struct conf {
/* connection to Redis */
char *redis_host;
int redis_port;
struct auth *redis_auth;
/* HTTP server interface */
char *http_host;
int http_port;
int http_threads;
size_t http_max_request_size;
/* pool size, one pool per worker thread */
int pool_size_per_thread;
/* daemonize process, off by default */
int daemonize;
char *pidfile;
/* WebSocket support, off by default */
int websockets;
/* database number */
int database;
/* ACL */
struct acl *perms;
/* user/group */
uid_t user;
gid_t group;
/* Logging */
char *logfile;
log_level verbosity;
struct {
log_fsync_mode mode;
int period_millis; /* only used with LOG_FSYNC_MILLIS */
} log_fsync;
#ifdef HAVE_SSL
/* SSL */
struct {
int enabled;
char *ca_cert_bundle; /* File name of trusted CA/ca bundle file, optional */
char *path_to_certs; /* Path of trusted certificates, optional */
char *client_cert_pem; /* File name of client certificate file, optional */
char *client_key_pem; /* File name of client private key, optional */
char *redis_sni; /* Server name to request (SNI), optional */
} ssl;
#endif
/* Request to serve on “/” */
char *default_root;
};
struct conf *
conf_read(const char *filename);
void
conf_free(struct conf *conf);
#endif /* CONF_H */
|
tsmekal/nodemcu
|
WifiDisplay/SensorData/SensorData.h
|
<gh_stars>0
#ifndef Morse_h
#define Morse_h
#include "Arduino.h"
#include <ArduinoJson.h>
class SensorData
{
public:
float temperature;
float humidity;
float pressure;
float VOC;
String label;
bool stateLed;
bool stateDisplay;
bool stateWarning;
SensorData();
String toJson();
};
#endif
|
tsmekal/nodemcu
|
WifiDisplay/htmlDashboard.h
|
const char htmlPageHeader[] = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n";
const char htmlPageBody[] = R"=====(
<!DOCTYPE html>
<html>
<head>
<meta name='viewport' content='width=device-width, initial-scale=1.0'/>
<meta charset='utf-8'>
<link href='https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css' rel='stylesheet' integrity='<KEY>' crossorigin='anonymous'>
<style>
body { font-size:100%;}
.container{ margin-top: 30px;}
</style>
<title>Data</title>
<style>
html, body{
background-color: #ff9900
}
#status{
position: absolute;
right: 8px;
top: 8px;
font-size: 0.8em;
}
</style>
</head>
<body>
<div class='container mt-5'>
<div class='row d-flex justify-content-center'>
<div class='col-md-4 col-sm-6 col-xs-12'>
<div class='card px-3 py-3' id='form1'>
<span id='status'></span>
<div class='row'>
<div class='col'>
<p>Temperature: <strong><span id='temp'></span>°C</strong></p>
<p>Humidity: <strong><span id='humid'></span>%</strong></p>
<p>Pressure: <strong><span id='pres'></span>hPa</strong></p>
<p>Air quality: <strong><span id='air'></span></strong></p>
</div>
</div>
<div class='row'>
<div class='col text-center d-grid'>
<button class='btn btn-outline-primary btn-sm btn-block' id='btnLED' onclick='onLedClick()'>LED</button>
</div>
<div class='col text-center d-grid'>
<button class='btn btn-outline-info btn-sm btn-block' id='btnDisplay' onclick='onDisplayClick()'>DISPLAY</button>
</div>
</div>
<div class='row mt-3'>
<div class='col text-center d-grid'>
<button class='btn btn-outline-danger btn-sm btn-block' id='btnResetWifi' onclick='onWifiResetClick()'>Reset WIFI configuration</button>
</div>
</div>
<div class='row mt-3 mb-0' id='lblWarning' style='display: none;'>
<div class='col'>
<div class='alert alert-danger'>Air quality is not good!</div>
</div>
</div>
</div>
</div>
</div>
</div>
</body>
<script>
var Socket;
var interval;
function init()
{
document.getElementById('status').innerHTML = 'Connecting to server...';
Socket = new WebSocket('ws://' + window.location.hostname + ':81/');
Socket.onmessage = function(event) { processReceivedCommand(event); };
Socket.addEventListener('open', (event) => {
document.getElementById('status').innerHTML = 'Connected to server';
interval = null;
});
Socket.addEventListener('close', (event) => {
console.log('disconnected');
document.getElementById('status').innerHTML = 'Connection closed';
interval = setInterval(function(){
init();
}, 5000)
});
}
function processReceivedCommand(evt)
{
var data = evt.data;
const obj = JSON.parse(data);
var tmp = data.split('|');
document.getElementById('temp').innerHTML = obj.temperature;
document.getElementById('humid').innerHTML = obj.humidity;
document.getElementById('pres').innerHTML = obj.pressure;
document.getElementById('air').innerHTML = obj.label + ' | VOC index: ' + obj.voc;
// LED status
if(obj.stateLed == 1){
document.getElementById('btnLED').innerHTML = 'Turn OFF LED';
}
else{
document.getElementById('btnLED').innerHTML = 'Turn ON LED';
}
// Display status
if(obj.stateDisplay == 1){
document.getElementById('btnDisplay').innerHTML = 'Turn OFF display';
}
else{
document.getElementById('btnDisplay').innerHTML = 'Turn ON display';
}
if(obj.stateWarning == 1){
document.getElementById('lblWarning').style.display = 'block';
}
else{
document.getElementById('lblWarning').style.display = 'none';
}
}
function sendText(data) {
Socket.send(data);
}
function onLedClick(){
sendText('LED');
}
function onDisplayClick(){
sendText('DISPLAY');
}
function onWifiResetClick(){
if(confirm('Really reset Wifi configuration?')){
sendText('RESET_WIFI');
}
}
window.onload = function(e) {
init();
}
</script>
</html>
)=====";
|
Demogorgon314/M5Paper_FactoryTest
|
src/global_setting.h
|
<filename>src/global_setting.h
#ifndef _GLOBAL_SETTING_H_
#define _GLOBAL_SETTING_H_
#include <M5EPD.h>
#include <nvs.h>
#define WALLPAPER_NUM 3
enum {
LANGUAGE_EN = 0, // default, English
LANGUAGE_JA, // Japanese
LANGUAGE_ZH // Simplified Chinese
};
void SetLanguage(uint8_t language);
uint8_t GetLanguage(void);
void SetWallpaper(uint16_t wallpaper_id);
uint16_t GetWallpaperID(void);
const uint8_t *GetWallpaper(void);
const char *GetWallpaperName(uint16_t wallpaper_id);
esp_err_t LoadSetting(void);
esp_err_t SaveSetting(void);
void SetWifi(String ssid, String password);
String GetWifiSSID(void);
String GetWifiPassword(void);
uint8_t isWiFiConfiged(void);
bool SyncNTPTime(void);
int8_t GetTimeZone(void);
void SetTimeZone(int8_t time_zone);
uint16_t GetTextSize();
void SetTextSize(uint16_t size);
const uint8_t *GetLoadingIMG_32x32(uint8_t id);
void LoadingAnime_32x32_Start(uint16_t x, uint16_t y);
void LoadingAnime_32x32_Stop();
uint8_t isTimeSynced(void);
void SetTimeSynced(uint8_t val);
void SetTTFLoaded(uint8_t val);
uint8_t isTTFLoaded(void);
void SetInitStatus(uint8_t idx, uint8_t val);
uint8_t GetInitStatus(uint8_t idx);
#endif //_GLOBAL_SETTING_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_fileindex.h
|
#ifndef _FRAME_FILEINDEX_H_
#define _FRAME_FILEINDEX_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
#include <SD.h>
class Frame_FileIndex : public Frame_Base {
public:
Frame_FileIndex(String path);
~Frame_FileIndex();
void listDir(fs::FS &fs, const char *dirname);
int init(epdgui_args_vector_t &args);
private:
std::vector<EPDGUI_Button *> _key_files;
String _path;
};
#endif //_FRAME_FILEINDEX_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_lifegame.h
|
<reponame>Demogorgon314/M5Paper_FactoryTest
#ifndef _FRAME_LIFEGAME_H_
#define _FRAME_LIFEGAME_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
class Frame_Lifegame : public Frame_Base {
public:
Frame_Lifegame();
~Frame_Lifegame();
int init(epdgui_args_vector_t &args);
int run();
void exit();
private:
M5EPD_Canvas *cells_0;
M5EPD_Canvas *cells_1;
M5EPD_Canvas *canvas_0;
M5EPD_Canvas *canvas_1;
};
#endif //_FRAME_LIFEGAME_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_pictureviewer.h
|
<filename>src/frame/frame_pictureviewer.h<gh_stars>0
#ifndef _FRAME_PICTUREVIEWER_H_
#define _FRAME_PICTUREVIEWER_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
class Frame_PictureViewer : public Frame_Base {
public:
Frame_PictureViewer(String path);
~Frame_PictureViewer();
int init(epdgui_args_vector_t &args);
int run();
void err(String info);
private:
M5EPD_Canvas *_canvas_picture;
String _pic_path;
bool _is_first;
};
#endif //_FRAME_PICTUREVIEWER_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_wifiscan.h
|
#ifndef _FRAME_WIFISCAN_H_
#define _FRAME_WIFISCAN_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
class Frame_WifiScan : public Frame_Base {
public:
Frame_WifiScan();
~Frame_WifiScan() override;
int init(epdgui_args_vector_t &args) override;
int scan();
int run() override;
void Connect();
static void DrawItem(EPDGUI_Button *btn, String ssid, int rssi);
void SetConnected(String ssid, int rssi);
private:
EPDGUI_Button *_key_wifi[14];
uint8_t _language;
uint32_t _scan_count = 0;
bool _connect;
uint8_t _connected;
String _connect_ssid;
String _connect_password;
};
#endif //_FRAME_SETTING_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_compare.h
|
#ifndef _FRAME_COMPARE_H_
#define _FRAME_COMPARE_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
class Frame_Compare : public Frame_Base {
public:
Frame_Compare();
~Frame_Compare();
int init(epdgui_args_vector_t &args);
int run();
private:
EPDGUI_Button *_key_updatemode[8];
uint8_t _update_flag;
M5EPD_Canvas *_canvas;
M5EPD_Canvas *_canvas_time;
};
#endif //_FRAME_COMPARE_H_
|
Demogorgon314/M5Paper_FactoryTest
|
src/epdgui/epdgui_keyboard.h
|
<filename>src/epdgui/epdgui_keyboard.h
#ifndef __EPDGUI_KEYBOARD_H
#define __EPDGUI_KEYBOARD_H
#include "epdgui_button.h"
#include "epdgui_switch.h"
class EPDGUI_Keyboard : public EPDGUI_Base {
public:
static const uint32_t STYLE_INPUTMODE_NORMALTEXT = 0x00000001;
static const uint32_t STYLE_INPUTMODE_NEEDCONFIRM = 0x00000002;
static const uint32_t STYLE_DEFAULT = STYLE_INPUTMODE_NORMALTEXT;
public:
EPDGUI_Keyboard(int16_t dir = 1, uint32_t style = STYLE_DEFAULT);
~EPDGUI_Keyboard();
void Draw(m5epd_update_mode_t mode = UPDATE_MODE_DU4);
void Draw(M5EPD_Canvas *canvas);
void Bind(int16_t event, void (*func_cb)(epdgui_args_vector_t &));
void UpdateState(int16_t x, int16_t y);
String getData(void);
private:
EPDGUI_Button *_btn[29];
EPDGUI_Switch *_sw[3];
EPDGUI_Base *_key[32];
String _data;
uint8_t _layout = 0;
public:
};
#endif //__EPDGUI_KEYBOARD_H
|
Demogorgon314/M5Paper_FactoryTest
|
src/systeminit.h
|
#ifndef __SYSTEMINIT_H
#define __SYSTEMINIT_H
#include <M5EPD.h>
void SysInit_Start(void);
void SysInit_Loading(void *pvParameters);
void SysInit_UpdateInfo(const String &info);
#endif //__SYSTEMINIT_H
|
Demogorgon314/M5Paper_FactoryTest
|
src/frame/frame_home.h
|
#ifndef _FRAME_HOME_H_
#define _FRAME_HOME_H_
#include "frame_base.h"
#include "../epdgui/epdgui.h"
class Frame_Home : public Frame_Base {
public:
Frame_Home();
~Frame_Home();
int init(epdgui_args_vector_t &args);
void InitSwitch(EPDGUI_Switch *sw, String title, String subtitle, const uint8_t *img1, const uint8_t *img2);
private:
EPDGUI_Switch *_sw_light1;
EPDGUI_Switch *_sw_light2;
EPDGUI_Switch *_sw_socket1;
EPDGUI_Switch *_sw_socket2;
EPDGUI_Switch *_sw_air_1;
EPDGUI_Switch *_sw_air_2;
EPDGUI_Button *_key_air_1_plus;
EPDGUI_Button *_key_air_1_minus;
EPDGUI_Button *_key_air_2_plus;
EPDGUI_Button *_key_air_2_minus;
};
#endif //_FRAME_HOME_H_
|
AlbertChen/CYAlertController
|
AlertControllerDemo/AlertControllerDemo/DatePickerView/DatePickerView.h
|
<reponame>AlbertChen/CYAlertController<filename>AlertControllerDemo/AlertControllerDemo/DatePickerView/DatePickerView.h
//
// DatePickerView.h
// AlertControllerDemo
//
// Created by <NAME> on 5/10/16.
// Copyright © 2016 <NAME>. All rights reserved.
//
#import "CYAlertController.h"
//typedef NS_ENUM(NSInteger, UIDatePickerMode) {
// UIDatePickerModeTime, // Displays hour, minute, and optionally AM/PM designation depending on the locale setting (e.g. 6 | 53 | PM)
// UIDatePickerModeDate, // Displays month, day, and year depending on the locale setting (e.g. November | 15 | 2007)
// UIDatePickerModeDateAndTime, // Displays date, hour, minute, and optionally AM/PM designation depending on the locale setting (e.g. Wed Nov 15 | 6 | 53 | PM)
// UIDatePickerModeCountDownTimer, // Displays hour and minute (e.g. 1 | 53)
//}
typedef NS_ENUM(NSInteger, DatePickerViewMode) {
DatePickerViewModeTime,
DatePickerViewModeDate,
DatePickerViewModeDateAndTime,
DatePickerViewModeYearAndMonth = 4,
};
@interface DatePickerView : CYAlertCustomView
+ (instancetype)datePickerViewWithMode:(DatePickerViewMode)mode selectedDate:(NSDate *)selectedDate completion:(void (^)(NSDate *date))completion;
@property (nonatomic, strong) NSDate *minimumDate;
@property (nonatomic, strong) NSDate *maximumDate;
@property (nonatomic, strong) void (^completion)(NSDate *date);
@end
|
AlbertChen/CYAlertController
|
CYAlertController/CYAlertController.h
|
//
// CYAlertController.h
// CYAlertController
//
// Created by <NAME> on 3/1/16.
// Copyright © 2016 <NAME>. All rights reserved.
//
#import <UIKit/UIKit.h>
/*
CYAlertController *alertController = [CYAlertController alertControllerWithImage:[UIImage imageNamed:@"已勾选"] message:@"Message"];
CYAlertAction *cancelAction = [CYAlertAction actionWithTitle:@"Cancel" handler:^(CYAlertAction *action) {
NSLog(@"Cancel button pressed.");
}];
CYAlertAction *okAction = [CYAlertAction actionWithTitle:@"OK" handler:^(CYAlertAction *action) {
NSLog(@"OK button pressed.");
}];
[alertController addAction:cancelAction];
[alertController addAction:okAction];
[alertController presentFromViewController:self animated:YES completion:NULL];
*/
typedef NS_ENUM(NSInteger, CYAlertControllerStyle) {
CYAlertControllerStyleAlert = 0,
CYAlertControllerStyleCustomAlert,
CYAlertControllerStyleCustomActionSheet,
CYAlertControllerStyleSystemAlert,
CYAlertControllerStyleSystemActionSheet,
};
@class CYAlertController;
@interface CYAlertCustomView : UIView
@property (nonatomic, weak) IBOutlet UILabel *titleLabel;
@property (nonatomic, weak) IBOutlet UIButton *okButton;
@property (nonatomic, weak) IBOutlet UIButton *cancelButton;
@property (nonatomic, assign) CGFloat offsetCenterY;
@property (nonatomic, weak, readonly) CYAlertController *alertController;
- (IBAction)cancelButtonPressed:(id)sender;
- (IBAction)okButtonPressed:(id)sender;
- (CYAlertController *)showFromViewController:(UIViewController *)viewController
preferredStyle:(CYAlertControllerStyle)preferredStyle
animated:(BOOL)animated;
- (CYAlertController *)showFromViewController:(UIViewController *)viewController
preferredStyle:(CYAlertControllerStyle)preferredStyle
animated:(BOOL)animated
maskColor:(UIColor *)maskColor;
- (void)hide:(BOOL)animated;
@end
@interface CYAlertAction : NSObject
+ (instancetype)actionWithTitle:(NSString *)title handler:(void (^)(CYAlertAction *action))handler;
+ (instancetype)actionWithTitle:(NSString *)title bold:(BOOL)bold handler:(void (^)(CYAlertAction *action))handler;
@property (nonatomic, readonly) NSString *title;
@property (nonatomic, assign) UIAlertActionStyle style;
@end
@interface CYAlertController : UIViewController
+ (instancetype)alertControllerWithTitle:(NSString *)title message:(NSString *)message preferredStyle:(CYAlertControllerStyle)preferredStyle;
+ (instancetype)alertControllerWithImage:(UIImage *)image message:(NSString *)message preferredStyle:(CYAlertControllerStyle)preferredStyle;
+ (instancetype)alertControllerWithCustomView:(CYAlertCustomView *)customView preferredStyle:(CYAlertControllerStyle)preferredStyle; // preferredStyle = CYAlertControllerStyleCustomAlert or CYAlertControllerStyleCustomActionSheet
- (void)addAction:(CYAlertAction *)action;
@property (nonatomic, readonly) NSArray<CYAlertAction *> *actions;
@property (nonatomic, copy) NSString *title;
@property (nonatomic, copy) UIImage *image;
@property (nonatomic, copy) NSString *message;
@property (nonatomic, strong) UIView *customView;
@property (nonatomic, strong) UIColor *maskColor;
@property (nonatomic, assign) CGFloat offsetCenterY; // Work only when style is CYAlertControllerStyleCustomAlert
@property (nonatomic, readonly) BOOL animated;
@property (nonatomic, readonly) CYAlertControllerStyle preferredStyle;
- (void)presentFromViewController:(UIViewController *)fromController animated:(BOOL)animated;
- (void)dismiss:(BOOL)animated;
@end
|
AlbertChen/CYAlertController
|
AlertControllerDemo/AlertControllerDemo/ViewController.h
|
//
// ViewController.h
// AlertControllerDemo
//
// Created by <NAME> on 4/28/17.
// Copyright © 2017 <NAME>. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface ViewController : UIViewController
@end
|
kumanmushi/SwipeDownDismissViewController
|
SwipeDownDismissViewController/SwipeDownDismissViewController.h
|
//
// SwipeDownDismissViewController.h
// SwipeDownDismissViewController
//
// Created by 村田真矢 on 2019/06/22.
// Copyright © 2019 村田真矢. All rights reserved.
//
#import <UIKit/UIKit.h>
//! Project version number for SwipeDownDismissViewController.
FOUNDATION_EXPORT double SwipeDownDismissViewControllerVersionNumber;
//! Project version string for SwipeDownDismissViewController.
FOUNDATION_EXPORT const unsigned char SwipeDownDismissViewControllerVersionString[];
// In this header, you should import all the public headers of your framework using statements like #import <SwipeDownDismissViewController/PublicHeader.h>
|
liufeigit/Van-lang
|
src/van_environ.c
|
// clang
#include "van_environ.h"
static void environ_evalExpr(VanEnviron *env,ASTNode *astNode);
static void environ_evalAssign(VanEnviron *env,ASTNode *astNode);
static void environ_evalIf(VanEnviron *env,ASTNode *astNode);
static void environ_evalWhile(VanEnviron *env,ASTNode *astNode);
static void environ_evalFor(VanEnviron *env,ASTNode *astNode);
static void __environ_evalForIn(VanEnviron *env,ASTNode *astNode);
static void __environ_evalForThree(VanEnviron *env,ASTNode *astNode);
static void environ_evalFunction(VanEnviron *env,ASTNode *astNode);
static void environ_evalClass(VanEnviron *env,ASTNode *astNode);
static void environ_evalBlock(VanEnviron *env,ASTNode *astNode);
static void environ_evalComma(VanEnviron *env,ASTNode *astNode);
static void environ_calCurScope(VanEnviron *env,char *name);
static void environ_calWriteScope(VanEnviron *env,char *name);
static void environ_calReadScope(VanEnviron *env,char *name);
static void environ_calCurBindObj(VanEnviron *env);
static int environ_dealJump(VanEnviron *env,ASTNode *astNode);
static void environ_evalContinue(VanEnviron *env,ASTNode *astNode);
static void environ_evalBreak(VanEnviron *env,ASTNode *astNode);
static void environ_evalReturn(VanEnviron *env,ASTNode *astNode);
static void environ_evalYield(VanEnviron *env,ASTNode *astNode);
static void environ_evalUp(VanEnviron *env,ASTNode *astNode);
static void environ_evalGlobal(VanEnviron *env,ASTNode *astNode);
static void environ_evalField(VanEnviron *env,ASTNode *astNode);
static void environ_evalStatic(VanEnviron *env,ASTNode *astNode);
static void environ_evalImport(VanEnviron *env,ASTNode *astNode);
static void environ_evalPrint(VanEnviron *env,ASTNode *astNode); // 测试
static void environ_evalMap(VanEnviron *env,ASTNode *astNode);
static void environ_evalList(VanEnviron *env,ASTNode *astNode);
static void environ_evalFunctionExpr(VanEnviron *env,ASTNode *astNode);
static void environ_evalClassExpr(VanEnviron *env,ASTNode *astNode);
static void environ_evalCall(VanEnviron *env,ASTNode *astNode);
static void environ_evalNew(VanEnviron *env,ASTNode *astNode);
static void environ_evalProperty(VanEnviron *env,ASTNode *astNode);
static void environ_evalSubscript(VanEnviron *env,ASTNode *astNode);
static void environ_evalIndentify(VanEnviron *env,ASTNode *astNode);
static void __environ_evalOutIndentify(VanEnviron *env,ASTNode *astNode);
static void environ_evalNumber(VanEnviron *env,ASTNode *astNode);
static void environ_evalNull(VanEnviron *env,ASTNode *astNode);
static void environ_evalTrue(VanEnviron *env,ASTNode *astNode);
static void environ_evalFalse(VanEnviron *env,ASTNode *astNode);
static void environ_evalSelf(VanEnviron *env,ASTNode *astNode);
static void environ_evalSuper(VanEnviron *env,ASTNode *astNode);
static void environ_evalString(VanEnviron *env,ASTNode *astNode);
// binary 相关
static void environ_evalBinary(VanEnviron *env,ASTNode *astNode);
static void environ_evalUnCome(VanEnviron *env,ASTNode *astNode);
static void environ_evalPrior(VanEnviron *env,ASTNode *astNode);
static void environ_evalNot(VanEnviron *env,ASTNode *astNode);
static void environ_evalReverse(VanEnviron *env,ASTNode *astNode);
static void environ_evalNegative(VanEnviron *env,ASTNode *astNode);
static void __environ_evalFunction(VanEnviron *env,ASTNode *astNode);
static void __environ_evalClass(VanEnviron *env,ASTNode *astNode);
VanEnviron *environ_create(){
VanEnviron *env=NULL;
VanMap *scopeDict=NULL;
VanList *callStack=NULL;
env=(VanEnviron *)calloc(1, sizeof(VanEnviron ));
scopeDict=map_create();
callStack=list_create(0);
env->scopeDict=scopeDict;
env->curScope=scopeDict;
env->callStack=callStack;
environ_init(env);
return env;
}
void environ_evalStr(VanEnviron *env,char *str){
}
// 内置如List/Map的初始化
void environ_init(VanEnviron *env){
environ_initBuiltin(env);
environ_initDynamic(env);
}
void environ_eval(VanEnviron *env,ASTNode *astNode){
ASTNode *parent=NULL;
while(astNode){
parent=astNode->parent;
if(environ_dealJump(env,astNode)){
break;
}
if(astNode->type==ASTType_Expr){
environ_evalExpr(env,astNode);
}
else if(astNode->type==ASTType_Assign){
environ_evalAssign(env,astNode);
}
else if(astNode->type==ASTType_If){
environ_evalIf(env,astNode);
}
else if(astNode->type==ASTType_While){
environ_evalWhile(env,astNode);
}
else if(astNode->type==ASTType_For){
environ_evalFor(env,astNode);
}
else if(astNode->type==ASTType_Function){
environ_evalFunction(env,astNode);
}
else if(astNode->type==ASTType_Class){
environ_evalClass(env,astNode);
}
else if(astNode->type==ASTType_Continue){
environ_evalContinue(env,astNode);
}
else if(astNode->type==ASTType_Break){
environ_evalBreak(env,astNode);
}
else if(astNode->type==ASTType_Return){ // 函数执行
environ_evalReturn(env,astNode);
}
else if(astNode->type==ASTType_Up){
environ_evalUp(env,astNode);
}
else if(astNode->type==ASTType_Global){
environ_evalGlobal(env,astNode);
}
else if(astNode->type==ASTType_Field){
environ_evalField(env,astNode);
}
else if(astNode->type==ASTType_Static){
environ_evalStatic(env,astNode);
}
else if(astNode->type==ASTType_Import){
environ_evalImport(env,astNode);
}
else if(astNode->type==ASTType_Print){
environ_evalPrint(env,astNode);
}
else if(astNode->type==ASTType_Block){
environ_evalBlock(env,astNode);
}
else{ // error
break;
}
if(environ_dealJump(env,astNode)){
break;
}
astNode=astNode->next;
}
}
static int environ_dealJump(VanEnviron *env,ASTNode *astNode){
int flag=0;
if(env->isReturn){
if(astNode->parent->op==ASTOp_FunctionBlock){
astNode->parent->wrap=env->returnValue;
env->isReturn=0;
}
flag=1;
}
if(env->isBreak){
flag=1;
}
if(env->isContinue){
flag=1;
}
return flag;
}
static void environ_evalExpr(VanEnviron *env,ASTNode *astNode){
ASTOp op=0;
op=astNode->op;
if(op==ASTOp_Indentify){
environ_evalIndentify(env,astNode);
}
else if(op==ASTOp_Int||op==ASTOp_Float){
environ_evalNumber(env,astNode);
}
else if(op==ASTOp_Null){
environ_evalNull(env,astNode);
}
else if(op==ASTOp_True){
environ_evalTrue(env,astNode);
}
else if(op==ASTOp_False){
environ_evalFalse(env,astNode);
}
else if(op==ASTOp_Self){
environ_evalSelf(env,astNode);
}
else if(op==ASTOp_Super){
environ_evalSuper(env,astNode);
}
else if(op==ASTOp_String){
environ_evalString(env,astNode);
}
else if(op==ASTOp_Map){
environ_evalMap(env,astNode);
}
else if(op==ASTOp_List){
environ_evalList(env,astNode);
}
else if(op==ASTOp_FunctionExpr){
environ_evalFunctionExpr(env,astNode);
}
else if(op==ASTOp_ClassExpr){
environ_evalClassExpr(env,astNode);
}
else if(op==ASTOp_Prior){
environ_evalPrior(env,astNode);
}
else if(op==ASTOp_Call){
environ_evalCall(env,astNode);
}
else if(op==ASTOp_Property){
environ_evalProperty(env,astNode);
}
else if(op==ASTOp_Subscript){
environ_evalSubscript(env,astNode);
}
else if(op==ASTOp_Not){
environ_evalNot(env,astNode);
}
else if(op==ASTOp_Reverse){
environ_evalReverse(env,astNode);
}
else if(op==ASTOp_New){
environ_evalNew(env,astNode);
}
else if(op==ASTOp_Negative){
environ_evalNegative(env,astNode);
}
else if(op>ASTOp_BinaryStart&&op<ASTOp_BinaryEnd){
environ_evalBinary(env,astNode);
}
}
static void environ_evalComma(VanEnviron *env,ASTNode *astNode){
ASTNode **nodeArr=NULL;
int length=0;
nodeArr=astNode->childArr;
length=astNode->childLength;
for(int i=0;i<length;i++){
environ_evalExpr(env, nodeArr[i]);
}
}
static void environ_evalAssign(VanEnviron *env,ASTNode *astNode){
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
ASTNode **nodeArr1=NULL;
ASTNode **nodeArr2=NULL;
int length1=0;
int length2=0;
ASTNode *leftNode1=NULL;
ASTNode *rightNode1=NULL;
leftNode=astNode->childArr[0];
rightNode=astNode->childArr[1];
nodeArr1=leftNode->childArr;
nodeArr2=rightNode->childArr;
length1=leftNode->childLength;
length2=rightNode->childLength;
for(int i=0;i<length2;i++){
rightNode=nodeArr2[i];
environ_evalExpr(env, rightNode);
}
for(int i=0;i<length1;i++){
leftNode=nodeArr1[i];
rightNode=nodeArr2[i<length2?i:length2-1];
// environ_evalExpr(env, rightNode);
if(leftNode->op==ASTOp_Indentify){
environ_calWriteScope(env, leftNode->data);
map_setValue(env->curScope, leftNode->data, rightNode->wrap); // ??? value|reference
}
else if(leftNode->op==ASTOp_Property){ // Map|Instance|Class|Function
leftNode1=leftNode->childArr[0];
rightNode1=leftNode->childArr[1];
environ_evalExpr(env, leftNode1);
if(leftNode1->wrap->type==DataType_Map){ // map
map_setValue(leftNode1->wrap->data, rightNode1->data, rightNode->wrap);
}
else if(leftNode1->wrap->type==DataType_Instance){ // instance
instance_setValue(leftNode1->wrap->data, rightNode1->data, rightNode->wrap);
}
else if(leftNode1->wrap->type==DataType_Class){ // class
class_setValue(leftNode1->wrap->data, rightNode1->data, rightNode->wrap);
}
else if(leftNode1->wrap->type==DataType_Function){ // function
function_setValue(leftNode1->wrap->data, rightNode1->data, rightNode->wrap);
}
}
else if(leftNode->op==ASTOp_Subscript){ // Map/List
leftNode1=leftNode->childArr[0];
rightNode1=leftNode->childArr[1];
environ_evalExpr(env, leftNode1);
environ_evalExpr(env, rightNode1);
if(leftNode1->wrap->type==DataType_Map){ // map
if(rightNode1->wrap->type==DataType_String){
map_setValue(leftNode1->wrap->data, rightNode1->data, rightNode->wrap);
}
}
else if(leftNode1->wrap->type==DataType_List){ // list
if(rightNode1->wrap->type==DataType_Int){
list_setValue(leftNode1->wrap->data, rightNode1->wrap->value.l, rightNode->wrap);
}
}
}
}
}
static void environ_evalIf(VanEnviron *env,ASTNode *astNode){
int blockLen=0;
ASTNode **nodeArr=NULL;
ASTNode *termNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
VanWrap *exprWrap=NULL;
int flag=0;
nodeArr=astNode->childArr;
blockLen=astNode->childLength;
for(int i=0;i<(blockLen>1?blockLen-1:blockLen);i++){
termNode=nodeArr[i];
exprNode=termNode->childArr[0];
blockNode=termNode->childArr[1];
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
if(exprWrap->type==DataType_Int||exprWrap->type==DataType_Float){
if(exprWrap->value.l){
environ_evalBlock(env, blockNode);
flag=1;
break;
}
}
}
if(!flag){
termNode=nodeArr[blockLen-1];
if(termNode->type==ASTType_Block){ // else
blockNode=termNode;
environ_evalBlock(env, blockNode);
}
else if(termNode->op==ASTOp_ElseIfTerm){
exprNode=termNode->childArr[0];
blockNode=termNode->childArr[1];
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
if(exprWrap->type==DataType_Int||exprWrap->type==DataType_Float){
if(exprWrap->value.l){
environ_evalBlock(env, blockNode);
}
}
}
}
}
static void environ_evalWhile(VanEnviron *env,ASTNode *astNode){
ASTNode *termNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
VanWrap *exprWrap=NULL;
termNode=astNode->childArr[0];
exprNode=termNode->childArr[0];
blockNode=astNode->childArr[1];
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
if(exprWrap->type==DataType_Int||exprWrap->type==DataType_Float){
while(exprWrap->value.l){
if(!env->isBreak){
environ_evalBlock(env, blockNode);
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
env->isContinue=0;
}
else{
break;
}
}
env->isBreak=0;
env->isContinue=0;
}
}
static void __environ_evalForThree(VanEnviron *env,ASTNode *astNode){
ASTNode *termNode=NULL;
ASTNode *startNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *endNode=NULL;
ASTNode *blockNode=NULL;
VanWrap *exprWrap=NULL;
termNode=astNode->childArr[0];
startNode=termNode->childArr[0];
exprNode=termNode->childArr[1];
endNode=termNode->childArr[2];
blockNode=astNode->childArr[1];
environ_evalAssign(env, startNode);
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
if(exprWrap->type==DataType_Int||exprWrap->type==DataType_Float){
while(exprWrap->value.l){
if(!env->isBreak){
environ_evalBlock(env, blockNode);
environ_evalAssign(env, endNode);
environ_evalExpr(env, exprNode);
exprWrap=exprNode->wrap;
env->isContinue=0;
}
else{
break;
}
}
env->isBreak=0;
env->isContinue=0;
}
}
static void __environ_evalForIn(VanEnviron *env,ASTNode *astNode){
ASTNode *termNode=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
ASTNode *blockNode=NULL;
ASTNode **leftArr=NULL;
ASTNode **rightArr=NULL;
ASTNode *_right=NULL;
ASTNode *_left=NULL;
int length=0;
termNode=astNode->childArr[0];
leftNode=termNode->childArr[0];
rightNode=termNode->childArr[1];
blockNode=astNode->childArr[1];
leftArr=leftNode->childArr;
rightArr=rightNode->childArr;
length=leftNode->childLength;
environ_evalComma(env, rightNode);
_right=rightArr[0];
if(_right->wrap->type==DataType_List){ // List
int _length=0;
VanList *_list=NULL;
VanList *_rList=NULL;
_list=_right->wrap->data;
_length=0; // list_length(_list)
for(int i=0;i<list_length(_list);i++){
int _flag=0;
if(!env->isBreak){
for(int j=0;j<length;j++){
_left=leftArr[j];
_right=rightArr[j];
_rList=_right->wrap->data;
if(i>=list_length(_rList)){
_flag=1;
break;
}
environ_calWriteScope(env, _left->data);
map_setValue(env->curScope, _left->data, list_getValue(_rList, i));
}
if(_flag){
break;
}
environ_evalBlock(env, blockNode);
env->isContinue=0;
}
else{
break;
}
}
}
env->isBreak=0;
env->isContinue=0;
}
static void environ_evalFor(VanEnviron *env,ASTNode *astNode){
ASTNode *termNode=NULL;
int length=0;
termNode=astNode->childArr[0];
length=termNode->childLength;
if(length==2){
__environ_evalForIn(env,astNode);
}
else if(length==3){
__environ_evalForThree(env,astNode);
}
}
static void environ_evalFunction(VanEnviron *env,ASTNode *astNode){
__environ_evalFunction(env,astNode);
}
static void environ_evalClass(VanEnviron *env,ASTNode *astNode){
__environ_evalClass(env,astNode);
}
static void environ_evalBlock(VanEnviron *env,ASTNode *astNode){
if(astNode->childLength){
environ_eval(env,astNode->childArr[0]);
}
}
// ???
static void environ_evalContinue(VanEnviron *env,ASTNode *astNode){
ASTNode *parent=NULL;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_WhileBlock||
parent->op==ASTOp_ForBlock){
env->isContinue=1;
break;
}
else if(parent->op==ASTOp_FunctionBlock||
parent->op==ASTOp_ClassBlock){
break;
}
parent=parent->parent;
}
}
static void environ_evalBreak(VanEnviron *env,ASTNode *astNode){
ASTNode *parent=NULL;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_WhileBlock||
parent->op==ASTOp_ForBlock){
env->isBreak=1;
break;
}
else if(parent->op==ASTOp_FunctionBlock||
parent->op==ASTOp_ClassBlock){
break;
}
parent=parent->parent;
}
}
static void environ_evalReturn(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
ASTNode *exprNode=NULL;
ASTNode *parent=NULL;
int flag=0;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_FunctionBlock){
flag=1;
break;
}
else if(parent->op==ASTOp_ClassBlock){
break;
}
parent=parent->parent;
}
if(flag){
exprNode=astNode->childArr[0];
environ_evalExpr(env, exprNode);
wrap=exprNode->wrap;
astNode->wrap=wrap;
env->returnValue=wrap;
env->isReturn=1;
}
}
static void environ_evalYield(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
ASTNode *exprNode=NULL;
ASTNode *parent=NULL;
int flag=0;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_FunctionBlock){
flag=1;
break;
}
else if(parent->op==ASTOp_ClassBlock){
break;
}
parent=parent->parent;
}
if(flag){
exprNode=astNode->childArr[0];
environ_evalExpr(env, exprNode);
wrap=exprNode->wrap;
astNode->wrap=wrap;
env->returnValue=wrap;
env->isReturn=1;
}
}
static void environ_evalUp(VanEnviron *env,ASTNode *astNode){
int length=0;
ASTNode **nodeArr=NULL;
ASTNode *parent=NULL;
VanMap *upScopeDict=NULL;
VanFunction *function=NULL;
length=astNode->childLength;
nodeArr=astNode->childArr;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_FunctionBlock){
if(length){
int _len=0;
_len=list_length(env->callStack);
function=list_getValue(env->callStack, _len-1)->data;
upScopeDict=function->upScopeDict;
for(int i=0;i<length;i++){
map_setValue(upScopeDict, nodeArr[i]->data, NULL);
}
}
break;
}
parent=parent->parent;
}
}
static void environ_evalGlobal(VanEnviron *env,ASTNode *astNode){
int length=0;
ASTNode **nodeArr=NULL;
ASTNode *parent=NULL;
VanMap *globalScopeDict=NULL;
VanFunction *function=NULL;
length=astNode->childLength;
nodeArr=astNode->childArr;
parent=astNode->parent;
while(parent){
if(parent->op==ASTOp_FunctionBlock){
if(length){
int _len=0;
_len=list_length(env->callStack);
function=list_getValue(env->callStack, _len-1)->data;
globalScopeDict=function->globalScopeDict;
for(int i=0;i<length;i++){
map_setValue(globalScopeDict, nodeArr[i]->data, NULL);
}
}
break;
}
parent=parent->parent;
}
}
static void environ_evalField(VanEnviron *env,ASTNode *astNode){
int length=0;
ASTNode **nodeArr=NULL;
ASTNode *parent=NULL;
length=astNode->childLength;
nodeArr=astNode->childArr;
parent=astNode->parent;
if(parent){
VanClass *cls=NULL;
if(parent->op==ASTOp_ClassBlock){ // ins
if(length){
cls=parent->parent->wrap->data;
for(int i=0;i<length;i++){
class_addInsField(cls, nodeArr[i]->data,NULL);
}
}
}
else if(parent->type==ASTType_Static){ // cls
if(length){
cls=parent->parent->parent->wrap->data;
for(int i=0;i<length;i++){
class_addClsField(cls, nodeArr[i]->data,NULL);
}
}
}
}
}
static void environ_evalStatic(VanEnviron *env,ASTNode *astNode){
ASTNode *element=NULL;
element=astNode->childArr[0];
if(element->type==ASTType_Function){
environ_evalFunction(env, element);
}
else if(element->type==ASTType_Field){
environ_evalField(env, element);
}
}
static void environ_evalImport(VanEnviron *env,ASTNode *astNode){
}
static void environ_evalPrint(VanEnviron *env,ASTNode *astNode){
ASTNode **nodeArr=NULL;
ASTNode *element=NULL;
char *str=NULL;
int length=0;
nodeArr=(ASTNode **)astNode->childArr;
length=astNode->childLength;
for(int i=0;i<length;i++){
element=nodeArr[i];
environ_evalExpr(env, element);
str=wrap_toString(element->wrap);
printf("%s",str);
}
printf("\n");
}
// expr相关
static void environ_evalMap(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanMap *map=NULL;
ASTNode *pair=NULL;
ASTNode *key=NULL;
ASTNode *expr=NULL;
int length=0;
length=astNode->childLength;
map=map_create();
for(int i=0;i<length;i++){
char *str=NULL;
int len=0;
pair=astNode->childArr[i];
key=pair->childArr[0];
expr=pair->childArr[1];
len=strlen(key->data)+1;
str=(char *)calloc(len, sizeof(char ));
strcpy(str,key->data);
environ_evalExpr(env, expr);
map_setValue(map, str, expr->wrap);
}
wrap=wrap_wrapMap(map);
astNode->wrap=wrap;
}
static void environ_evalList(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanList *list=NULL;
ASTNode *node=NULL;
int length=0;
length=astNode->childLength;
list=list_create(0);
for(int i=0;i<length;i++){
node=astNode->childArr[i];
environ_evalExpr(env, node);
list_push(list, node->wrap);
}
wrap=wrap_wrapList(list);
astNode->wrap=wrap;
}
static void __environ_evalFunction(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanFunction *function=NULL;
char *name=NULL;
char **argNameArr=NULL;
int *outFlagArr=NULL;
int argArrLength=0;
ASTNode *nameNode=NULL;
ASTNode *argNode=NULL;
ASTNode *blockNode=NULL;
VanList *chainScopeList=NULL;
int length=0;
nameNode=astNode->childArr[0];
argNode=astNode->childArr[1];
blockNode=astNode->childArr[2];
if(nameNode){
if(nameNode->data){
name=(char *)calloc(strlen(nameNode->data)+1, sizeof(char ));
strcpy(name,nameNode->data);
}
}
if(argNode){
if(argNode->childLength){
argArrLength=argNode->childLength;
argNameArr=(char **)calloc(argArrLength, sizeof(char *));
outFlagArr=(int *)calloc(argArrLength, sizeof(int ));
for(int i=0;i<argArrLength;i++){
ASTNode *_node=NULL;
_node=argNode->childArr[i];
argNameArr[i]=(char *)calloc(strlen(_node->data)+1, sizeof(char ));
strcpy(argNameArr[i],_node->data);
if(_node->value.outFlag){
outFlagArr[i]=1;
}
}
}
}
function=function_create(name, argNameArr,outFlagArr, argArrLength);
function->code=blockNode;
chainScopeList=list_create(0);
length=list_length(env->callStack);
for(int i=0;i<length;i++){
VanFunction *_func=NULL;
VanWrap *_wrap=NULL;
_func=list_getValue(env->callStack, i)->data;
_wrap=wrap_wrapMap(_func->inScopeDict);
list_push(chainScopeList, _wrap);
}
function->chainScopeList=chainScopeList;
wrap=wrap_wrapFunction(function);
if(name){
ASTNode *parent=NULL;
int flag=1;
parent=astNode->parent;
if(parent){
VanClass *cls=NULL;
if(parent->op==ASTOp_ClassBlock){
cls=parent->parent->wrap->data;
class_addInsField(cls, function->name,wrap);
flag=0;
}
else if(parent->type==ASTType_Static){
cls=parent->parent->parent->wrap->data;
class_addClsField(cls, function->name,wrap);
flag=0;
}
}
// while(parent){
// if(parent->op==ASTOp_ClassBlock){
// VanClass *cls=NULL;
// cls=parent->parent->wrap->data;
// class_addInsField(cls, function->name,wrap);
// flag=0;
// break;
// }
// else if(parent->op==ASTOp_FunctionBlock){
// break;
// }
// parent=parent->parent;
// }
if(flag){
environ_calWriteScope(env, name);
map_setValue(env->curScope, name, wrap);
}
}
astNode->wrap=wrap;
}
// function-->call
static void environ_evalFunctionExpr(VanEnviron *env,ASTNode *astNode){
__environ_evalFunction(env,astNode);
}
static void __environ_evalClass(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanClass *cls=NULL;
char *name=NULL;
VanClass *base=NULL; // class
ASTNode *nameNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
nameNode=astNode->childArr[0];
exprNode=astNode->childArr[1];
blockNode=astNode->childArr[2];
if(nameNode){
if(nameNode->data){
name=(char *)calloc(strlen(nameNode->data)+1, sizeof(char ));
strcpy(name,nameNode->data);
}
}
if(exprNode){
environ_evalExpr(env, exprNode);
if(exprNode->wrap->type==DataType_Class){
base=exprNode->wrap->data;
}
}
cls=class_create(name, base);
wrap=wrap_wrapClass(cls);
astNode->wrap=wrap;
environ_evalBlock(env, blockNode);
if(name){
environ_calWriteScope(env, name);
map_setValue(env->curScope, name, wrap);
}
}
// class-->new
static void environ_evalClassExpr(VanEnviron *env,ASTNode *astNode){
__environ_evalClass(env,astNode);
}
static void environ_evalCall(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanFunction *function=NULL;
VanClass *cls=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
ASTNode *codeNode=NULL;
VanList *argList=NULL;
ASTNode **argArr=NULL;
int length=0;
int flag=0;
VanMap *upScopeDict=NULL;
VanMap *globalScopeDict=NULL;
VanMap *inScopeDict=NULL;
leftNode=astNode->childArr[0];
rightNode=astNode->childArr[1];
environ_evalExpr(env, leftNode);
if(leftNode->wrap){
flag=1;
if(leftNode->wrap->type==DataType_Function||
leftNode->wrap->type==DataType_Class){
VanClass *_cls=NULL;
if(leftNode->wrap->type==DataType_Class){
if(!astNode_hasNewParent(astNode)){
printf(">>> throw NewError\n");
exit(0);
}
_cls=leftNode->wrap->data;
if(_cls->type==ClassType_NativeClass){ // __new__
VanWrap *_value=NULL;
int _flag=0;
_value=class_getValue(_cls, "__new__", 0);
if(_value){
if(_value->type==DataType_Function){
function=_value->data;
_flag=1;
}
}
if(!_flag){
printf(">>> throw CallError\n");
exit(0);
}
}
else{ // __ctor__
VanInstance *_ins=NULL;
VanWrap *_value=NULL;
int _flag=0;
wrap=instance_create(_cls,NULL);
_ins=wrap->data;
_value=instance_getValue(_ins, "__ctor__", 0);
if(_value){
if(_value->type==DataType_Function){
function=_value->data;
_flag=1;
}
}
if(!_flag){
astNode->wrap=wrap;
return ;
}
}
}
else{
function=leftNode->wrap->data;
}
codeNode=function->code;
length=rightNode->childLength;
argArr=(ASTNode **)rightNode->childArr;
upScopeDict=map_create();
globalScopeDict=map_create();
inScopeDict=map_create();
if(length){
argList=list_create(0);
for(int i=0;i<length;i++){
// env->curScope=env->scopeDict;
// environ_evalExpr(env, argArr[i]);
// env->curScope=function->inScopeDict;
// map_setValue(env->curScope, function->argNameArr[i], argArr[i]->wrap);
if(i<function->argArrLength){
if(argArr[i]->op==ASTOp_Indentify){
if(!argArr[i]->value.outFlag&&!function->outFlagArr[i]){
environ_evalExpr(env, argArr[i]);
map_setValue(inScopeDict, function->argNameArr[i], argArr[i]->wrap);
list_push(argList, argArr[i]->wrap);
}
else if(argArr[i]->value.outFlag&&function->outFlagArr[i]){
__environ_evalOutIndentify(env,argArr[i]);
map_setRefValue(inScopeDict, function->argNameArr[i], argArr[i]->wrap);
list_push(argList, argArr[i]->wrap);
}
else{
printf(">>> throw CallError\n");
exit(0);
}
}
else{
environ_evalExpr(env, argArr[i]);
map_setValue(inScopeDict, function->argNameArr[i], argArr[i]->wrap);
list_push(argList, argArr[i]->wrap);
}
}
else{
environ_evalExpr(env, argArr[i]);
list_push(argList, argArr[i]->wrap);
}
}
}
if(leftNode->wrap->type==DataType_Class){ // __new__
cls=leftNode->wrap->data;
wrap=instance_create(cls,argList);
astNode->wrap=wrap;
return ;
}
if(function->type==FunctionType_Normal){
function->upScopeDict=upScopeDict;
function->globalScopeDict=globalScopeDict;
function->inScopeDict=inScopeDict;
function->argList=argList;
list_push(env->callStack, leftNode->wrap); // push
// if(function->bindObj){
// env->curIns=function->bindObj->data;
// }
// env->curScope=function->inScopeDict;
// environ_evalBlock(env,codeNode);
// env->curScope=env->scopeDict;
environ_evalBlock(env,codeNode);
if(leftNode->wrap->type==DataType_Function){ // not class __ctor__
wrap=codeNode->wrap; // ??? is null
}
list_pop(env->callStack); // pop
}
else{ // NativeFunction
WrapMethod _method=NULL;
_method=function->code;
wrap=_method(function->bindObj,argList);
}
}
else if(leftNode->wrap->type==DataType_Class){
cls=leftNode->wrap->data;
length=rightNode->childLength;
argArr=(ASTNode **)rightNode->childArr;
wrap=instance_create(cls,NULL);
}
else if(leftNode->wrap->type==DataType_NativeFunction){
// ??? 原生方法
VanNativeFunction *_func=NULL;
WrapMethod _method=NULL;
VanList *_argList=NULL;
length=rightNode->childLength;
argArr=(ASTNode **)rightNode->childArr;
_func=leftNode->wrap->data;
_method=_func->method;
_argList=list_create(0);
for(int i=0;i<length;i++){
environ_evalExpr(env, argArr[i]);
list_push(_argList, argArr[i]->wrap);
}
wrap=_method(NULL,_argList);
}
else{
flag=0;
}
}
if(!flag){
printf(">>> throw CallError\n");
exit(0);
}
astNode->wrap=wrap;
}
// new A; new A()==> A() evalCall
static void environ_evalNew(VanEnviron *env,ASTNode *astNode){
ASTNode *node=NULL;
VanWrap *wrap=NULL;
node=astNode->childArr[0];
environ_evalExpr(env, node);
if(node->wrap){
if(node->wrap->type==DataType_Class){
wrap=instance_create(node->wrap->data,NULL);
}
else if(astNode_hasClassChild(astNode)){
wrap=node->wrap;
}
}
if(!wrap){
printf(">>> throw NewError\n");
exit(0);
}
astNode->wrap=wrap;
}
// instance
static void environ_evalProperty(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanWrap *leftWrap=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
int flag=0;
leftNode=astNode->childArr[0];
rightNode=astNode->childArr[1];
environ_evalExpr(env, leftNode);
leftWrap=leftNode->wrap;
if(leftWrap){
flag=1;
if(leftWrap->type==DataType_Instance){ // instance
wrap=instance_getValue(leftWrap->data, rightNode->data,leftWrap->value.l);
}
else if(leftWrap->type==DataType_Class){ // class
wrap=class_getValue(leftWrap->data, rightNode->data,leftWrap->value.l);
}
else if(leftWrap->type==DataType_Map){ // map
wrap=map_getValue(leftWrap->data, rightNode->data);
}
else if(leftWrap->type==DataType_List){ // List ???
VanClass *_cls=NULL;
VanFunction *_func=NULL;
_cls=map_getValue(env->scopeDict, "List")->data;
wrap=map_getValue(_cls->insDescDict, rightNode->data);
if(wrap->type==DataType_Function){
function_bind(wrap->data, leftWrap);
_func=wrap->data;
if(wrap->_fieldDesc==FieldDesc_IsGet){
}
}
// wrap=map_getValue(leftWrap->data, rightNode->data);
}
else if(leftWrap->type==DataType_Function){ // function
wrap=function_getValue(leftWrap->data, rightNode->data);
}
else{
flag=0;
}
}
if(!flag){
printf(">>> throw PropertyError\n");
exit(0);
}
astNode->wrap=wrap;
}
// list/map
static void environ_evalSubscript(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanWrap *leftWrap=NULL;
VanWrap *rightWrap=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
int flag=0;
leftNode=astNode->childArr[0];
rightNode=astNode->childArr[1];
environ_evalExpr(env, leftNode);
environ_evalExpr(env, rightNode);
leftWrap=leftNode->wrap;
rightWrap=rightNode->wrap;
if(leftWrap){
if(leftWrap->type==DataType_List){ // List
if(rightWrap->type==DataType_Int){
wrap=list_getValue(leftWrap->data, rightWrap->value.l);
flag=1;
}
}
else if(leftWrap->type==DataType_Map){ // Map
if(rightWrap->type==DataType_String){
VanString *_vStr=NULL;
_vStr=rightWrap->data;
wrap=map_getValue(leftWrap->data, _vStr->data);
flag=1;
}
}
else if(leftWrap->type==DataType_Instance){ // Instance
}
else if(leftWrap->type==DataType_Class){ // Class
}
else if(leftWrap->type==DataType_Function){ // Function
}
}
if(!flag){
printf(">>> throw SubscriptError\n");
exit(0);
}
astNode->wrap=wrap;
}
/***
inScopeDict==>cur function
upScopeDict==>pre function
globalScopeDict==> global
global>up>in
****/
static void environ_calCurScope(VanEnviron *env,char *name){
}
// write global declare->up declare->cur
static void environ_calWriteScope(VanEnviron *env,char *name){
int length=0;
VanFunction *function=NULL;
VanMap *curScope=NULL;
int flag=0;
VanMap *upScopeDict=NULL;
VanMap *globalScopeDict=NULL;
VanMap *inScopeDict=NULL;
VanList *chainScopeList=NULL;
length=list_length(env->callStack);
if(length){
function=list_getValue(env->callStack, length-1)->data;
globalScopeDict=function->globalScopeDict;
upScopeDict=function->upScopeDict;
inScopeDict=function->inScopeDict;
chainScopeList=function->chainScopeList;
// 1. global declare
flag=map_hasKey(globalScopeDict, name);
if(flag){
curScope=env->scopeDict;
}
// 2. up declare
if(!flag){
flag=map_hasKey(upScopeDict, name);
if(flag){
VanMap *_inScopeDict=NULL;
length=list_length(function->chainScopeList);
for(int i=length-1;i>=0;i--){
_inScopeDict=list_getValue(chainScopeList, i)->data;
flag=map_hasKey(_inScopeDict, name);
if(flag){
curScope=_inScopeDict;
break;
}
}
}
}
// cur
if(!flag){
curScope=inScopeDict;
flag=1;
}
}
if(!flag){
curScope=env->scopeDict;
}
env->curScope=curScope;
}
// read global declare->up declare->cur->up->global
static void environ_calReadScope(VanEnviron *env,char *name){
int length=0;
VanFunction *function=NULL;
VanMap *curScope=NULL;
int flag=0;
VanMap *upScopeDict=NULL;
VanMap *globalScopeDict=NULL;
VanMap *inScopeDict=NULL;
VanList *chainScopeList=NULL;
length=list_length(env->callStack);
if(length){
function=list_getValue(env->callStack, length-1)->data;
globalScopeDict=function->globalScopeDict;
upScopeDict=function->upScopeDict;
inScopeDict=function->inScopeDict;
chainScopeList=function->chainScopeList;
// 1. global declare
flag=map_hasKey(globalScopeDict, name);
if(flag){
curScope=env->scopeDict;
}
// 2. up declare
if(!flag){
flag=map_hasKey(upScopeDict, name);
if(flag){
VanMap *_inScopeDict=NULL;
length=list_length(function->chainScopeList);
for(int i=length-1;i>=0;i--){
_inScopeDict=list_getValue(chainScopeList, i)->data;
flag=map_hasKey(_inScopeDict, name);
if(flag){
curScope=_inScopeDict;
break;
}
}
}
}
// cur
if(!flag){
flag=map_hasKey(inScopeDict, name);
if(flag){
curScope=inScopeDict;
}
}
// up
if(!flag){
VanMap *_inScopeDict=NULL;
length=list_length(function->chainScopeList);
for(int i=length-1;i>=0;i--){
_inScopeDict=list_getValue(chainScopeList, i)->data;
flag=map_hasKey(_inScopeDict, name);
if(flag){
curScope=_inScopeDict;
break;
}
}
}
// global
if(!flag){
curScope=env->scopeDict;
flag=1;
}
}
if(!flag){
curScope=env->scopeDict;
}
env->curScope=curScope;
}
static void environ_calCurBindObj(VanEnviron *env){
int length=0;
VanFunction *function=NULL;
length=list_length(env->callStack);
if(length){
function=list_getValue(env->callStack, length-1)->data;
env->curBindObj=function->bindObj;
// if(function->bindObj){
// env->curIns=function->bindObj->data;
// }
}
}
// simple literal scope==>get
static void environ_evalIndentify(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
int flag=0;
environ_calReadScope(env, astNode->data);
flag=map_hasKey(env->curScope, astNode->data);
if(flag){
wrap=map_getValue(env->curScope, astNode->data);
wrap_retain(wrap);
}
// else {
// flag=map_hasKey(env->scopeDict, astNode->data);
// if(flag){
// wrap=map_getValue(env->scopeDict, astNode->data);
// wrap_retain(wrap);
// }
// }
astNode->wrap=wrap;
}
static void __environ_evalOutIndentify(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
int flag=0;
environ_calReadScope(env, astNode->data);
flag=map_hasKey(env->curScope, astNode->data);
if(flag){
wrap=map_getRefValue(env->curScope, astNode->data);
wrap_retain(wrap);
}
// else {
// flag=map_hasKey(env->scopeDict, astNode->data);
// if(flag){
// wrap=map_getValue(env->scopeDict, astNode->data);
// wrap_retain(wrap);
// }
// }
astNode->wrap=wrap;
}
static void environ_evalNumber(VanEnviron *env,ASTNode *astNode){
if(astNode->op==ASTOp_Int){
astNode->wrap=wrap_wrapLongLong(astNode->value.l);
}
else if(astNode->op==ASTOp_Float){
astNode->wrap=wrap_wrapDouble(astNode->value.d);
}
}
static void environ_evalNull(VanEnviron *env,ASTNode *astNode){
astNode->wrap=wrap_wrapInt(0);
}
static void environ_evalTrue(VanEnviron *env,ASTNode *astNode){
astNode->wrap=wrap_wrapInt(1);
}
static void environ_evalFalse(VanEnviron *env,ASTNode *astNode){
astNode->wrap=wrap_wrapInt(0);
}
static void environ_evalSelf(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
environ_calCurBindObj(env);
wrap=env->curBindObj;
wrap->value.l=0;
astNode->wrap=wrap;
}
static void environ_evalSuper(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
environ_calCurBindObj(env);
wrap=env->curBindObj;
wrap->value.l=1; // ???
// if(wrap){
// if(wrap->type==DataType_Instance){
// wrap->value.l=1; // ???
// }
// else if(wrap->type==DataType_Class){
// VanClass *cls=NULL;
// cls=wrap->data;
// wrap=wrap_wrapClass(cls->base);
// }
// }
astNode->wrap=wrap;
}
static void environ_evalString(VanEnviron *env,ASTNode *astNode){
VanWrap *wrap=NULL;
VanString *vanStr=NULL;
int len=0;
char *data1=NULL;
len=strlen(astNode->data)+1;
data1=(char *)calloc(len+1, sizeof(char ));
strcpy(data1,astNode->data);
vanStr=string_create(data1);
wrap=wrap_wrapString(vanStr);
astNode->wrap=wrap;
}
// binary相关 astNode optimizer ???
static void environ_evalBinary(VanEnviron *env,ASTNode *astNode){
ASTOp op=0;
ASTNode **childArr=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
VanWrap *wrap=NULL;
VanWrap *leftWrap=NULL;
VanWrap *rightWrap=NULL;
childArr=(ASTNode **)astNode->childArr;
leftNode=childArr[0];
rightNode=childArr[1];
environ_evalExpr(env, leftNode);
environ_evalExpr(env, rightNode);
leftWrap=leftNode->wrap;
rightWrap=rightNode->wrap;
op=astNode->op;
wrap=wrap_binaryCal(leftWrap,rightWrap,op);
if(!wrap){
printf(">>> throw OperateError\n");
exit(0);
}
astNode->wrap=wrap;
}
static void environ_evalPrior(VanEnviron *env,ASTNode *astNode){
ASTNode *node=NULL;
node=astNode->childArr[0];
environ_evalExpr(env,node);
wrap_retain(node->wrap);
astNode->wrap=node->wrap;
}
static void environ_evalNot(VanEnviron *env,ASTNode *astNode){
ASTNode *node=NULL;
VanWrap *wrap=NULL;
node=astNode->childArr[0];
environ_evalExpr(env,node);
if(node->wrap->type==DataType_Int){
wrap=wrap_wrapLongLong(!node->wrap->value.l);
}
else if(node->wrap->type==DataType_Float){
wrap=wrap_wrapLongLong(!node->wrap->value.d);
}
astNode->wrap=wrap;
}
static void environ_evalReverse(VanEnviron *env,ASTNode *astNode){
ASTNode *node=NULL;
VanWrap *wrap=NULL;
node=astNode->childArr[0];
environ_evalExpr(env,node);
if(node->wrap->type==DataType_Int){
wrap=wrap_wrapLongLong(~node->wrap->value.l);
}
astNode->wrap=wrap;
}
static void environ_evalNegative(VanEnviron *env,ASTNode *astNode){
ASTNode *node=NULL;
VanWrap *wrap=NULL;
node=astNode->childArr[0];
environ_evalExpr(env,node);
if(node->wrap->type==DataType_Int){
wrap=wrap_wrapLongLong(-node->wrap->value.l);
}
else if(node->wrap->type==DataType_Float){
wrap=wrap_wrapLongLong(-node->wrap->value.d);
}
astNode->wrap=wrap;
}
static void environ_evalUnCome(VanEnviron *env,ASTNode *astNode){
astNode->wrap=wrap_wrapInt(0);
}
|
liufeigit/Van-lang
|
src/van_lex.c
|
// clang
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "van_lex.h"
int __lex_strLen=0;
int __lex_curRow=0;
int __lex_curCol=0;
static Token *lexComment(char *str,int cur,int end);
static Token *lexIdentify(char *str,int cur,int end);
static Token *lexKeyword(char *str,int cur,int end);
static Token *lexLiteral(char *str,int cur,int end);
static Token *lexOperator(char *str,int cur,int end);
static Token *lexDelimiter(char *str,int cur,int end);
static int lexFilterWs(char *str,int cur);
static int __convertUTF8(char *str,int index,char *str1,int index1);
static char *__convertString(char *str);
static int __isHex(char c);
static int __lexUniHex(char *str,int cur);
static int __lexEscape(char *str,int cur);
static int __lexString(char *str,char **data);
static int __lexInt(char *str,long long *data);
static int __lexFloat(char *str,double *data);
static int __isComment(char *str,int cur);
static int __isIdentify(char *str,int cur);
static int __isKeyword(char *str,int cur);
static int __isLiteral(char *str,int cur);
static int __isOperator(char *str,int cur);
static int __isDelimiter(char *str,int cur);
static int __isString(char *str,int cur);
static int __isNumber(char *str,int cur);
static int __isInt(char *str);
static int __isFloat(char *str);
static int __isTrue(char *str,int cur);
static int __isFalse(char *str,int cur);
static int __isNull(char *str,int cur);
static int __isDigit(char *str,int cur);
static int __isDotDigit(char *str,int cur);
int lexStr(char *str,Token **headToken,Token **tailToken){
int offset=0;
int end=0;
Token *head=NULL;
Token *curToken=NULL;
__lex_strLen=strlen(str);
offset=lexFilterWs(str, offset);
while(offset<__lex_strLen){
Token *_token=NULL;
end=0;
if((end=__isComment(str,offset))){
_token=lexComment(str,offset,end);
}
else if((end=__isLiteral(str,offset))){
_token=lexLiteral(str,offset,end);
}
else if((end=__isKeyword(str,offset))){
_token=lexKeyword(str,offset,end);
}
else if((end=__isIdentify(str,offset))){
_token=lexIdentify(str,offset,end);
}
else if((end=__isOperator(str,offset))){
_token=lexOperator(str,offset,end);
}
else if((end=__isDelimiter(str,offset))){
_token=lexDelimiter(str,offset,end);
}
if(end&&_token){
offset=end;
offset=lexFilterWs(str, offset);
if(_token->type!=TokenType_Comment){
if(!head){
head=_token;
curToken=_token;
}
else{
curToken->next=_token;
_token->pre=curToken;
curToken=_token;
}
}
else{
freeToken(_token);
}
}
else{ // error处理
printf(">>> throw LexError: line %d, column %d\n",__lex_curRow+1,__lex_curCol+1);
freeToken(_token);
freeToken(curToken);
offset=0;
break;
}
}
if(offset){
Token *tail=NULL;
tail=(Token *)calloc(1, sizeof(Token ));
tail->type=TokenType_Delimiter;
tail->subType=TokenSubType_Semicolon;
curToken->next=tail;
tail->pre=curToken;
if(tailToken){
*tailToken=tail;
}
if(headToken){
*headToken=head;
}
if(!headToken&&!tailToken){
freeToken(tail);
}
}
return offset;
}
static int lexFilterWs(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return cur;
}
offset=cur;
while(cur<__lex_strLen){
if(str[cur]=='\x0a'||str[cur]=='\x09'||
str[cur]=='\x0d'||str[cur]=='\x20'){ // \n \t \r space
if(str[cur]=='\x0a'){
__lex_curCol=0;
__lex_curRow++;
}
else if(str[cur]=='\x09'||str[cur]=='\x20'){ // ??? \r
__lex_curCol++;
}
cur++;
offset=cur;
}
else{
break;
}
}
return offset;
}
/***
0000~007f --> 0xxxxxxx
0080~07ff --> 110xxxxx 10xxxxxx
0800~ffff --> 1110xxxx 10xxxxxx 10xxxxxx
.....
>=2 取位存码 第一字节补0按8位掩码 其它字节移位后6位掩码取位
****/
static int __convertUTF8(char *str,int index,char *str1,int index1){
int len=0;
int value=0;
int fact=1;
char a='\0';
for(int i=index+3;i>=index;i--){
if(str[i]>='0'&&str[i]<='9'){
a=str[i]-'0';
}
else if(str[i]>='a'&&str[i]<='f'){
a=10+str[i]-'a';
}
else if(str[i]>='A'&&str[i]<='F'){
a=10+str[i]-'A';
}
if(i==index+3){
value=value+a;
}
else{
fact*=16;
value=value+a*fact;
}
}
if(value>=0x0000&&value<=0x007f){
str1[index1]=value;
len++;
}
else if(value>=0x0080&&value<=0x07ff){
str1[index1]=0xc0|((value>>6)&0xff); // 110
str1[index1+1]=0x80|(value&0x3f); // 10
len+=2;
}
else if(value>=0x0800&&value<=0xffff){
str1[index1]=0xe0|((value>>12)&0xff); // 1110
str1[index1+1]=0x80|((value>>6)&0x3f); // 10
str1[index1+2]=0x80|(value&0x3f); // 10
len+=3;
}
return len;
}
// str=> " "
static char *__convertString(char *str){
char *data=NULL;
int length=0;
int _length=0;
length=strlen(str);
data=(char *)malloc((length+1)*sizeof(char));
for(int i=1,j=0;i<length-1;i++,j++){
if(str[i]=='\\'){
if(str[i+1]=='\"'){
data[j]='\"';
i++;
}
else if(str[i+1]=='\\'){
data[j]='\\';
i++;
}
else if(str[i+1]=='/'){
data[j]='/';
i++;
}
else if(str[i+1]=='b'){
data[j]='\b';
i++;
}
else if(str[i+1]=='f'){
data[j]='\f';
i++;
}
else if(str[i+1]=='n'){
data[j]='\n';
i++;
}
else if(str[i+1]=='r'){
data[j]='\r';
i++;
}
else if(str[i+1]=='t'){
data[j]='\t';
i++;
}
else if(str[i+1]=='u'){
int _len=0;
_len=__convertUTF8(str,i+2,data,j);
j+=(_len-1);
i+=5;
}
else{ // error
data[j]=str[i];
}
}
else{
data[j]=str[i];
}
_length=j;
}
data[_length+1]='\0';
return data;
}
static int __isHex(char c){
int status=0;
if((c>='0'&&c<='9')||
(c>='A'&&c<='F')||
(c>='a'&&c<='f')){
status=1;
}
return status;
}
static int __lexUniHex(char *str,int cur){
int offset=0;
int num=0;
int _length=0;
_length=strlen(str);
cur++;
if(cur>=_length){
return 0;
}
while(__isHex(str[cur])){
cur++;
num++;
if(num==4){
break;
}
if(cur>=_length){
return 0;
}
}
if(num==4){
offset=cur;
}
return offset;
}
static int __lexEscape(char *str,int cur){
int offset=0;
int _length=0;
_length=strlen(str);
cur++;
if(cur>=_length){
return 0;
}
if(str[cur]=='\"'||
str[cur]=='\\'||
str[cur]=='/'||
str[cur]=='b'||
str[cur]=='f'||
str[cur]=='n'||
str[cur]=='r'||
str[cur]=='t'){
cur++;
}
else if(str[cur]=='u'){
cur=__lexUniHex(str,cur);
}
else{
cur=0;
}
offset=cur;
return offset;
}
// str==>" "
static int __lexString(char *str,char **data){
int offset=0;
int cur=0;
int _length=0;
_length=strlen(str);
cur++;
while(str[cur]!='\"'){
if(str[cur]=='\\'){
cur=__lexEscape(str,cur);
if(cur==0){
break;
}
}
else{
cur++;
}
if(cur>=_length){
return 0;
}
}
if(cur&&str[cur]=='\"'){
offset=cur+1;
}
if(offset){
*data=__convertString(str);
}
return offset;
}
static int __lexInt(char *str,long long *data){
int status=1;
long long v=0;
char *str1=NULL;
v=strtol(str,&str1,10);
*data=v;
if(v==0&&str[0]!='0'){
status=0;
}
return status;
}
static int __lexFloat(char *str,double *data){
int status=1;
double v=0;
char *str1=NULL;
v=strtod(str,&str1);
*data=v;
if(v==0){
status=0;
}
return status;
}
static Token *lexDelimiter(char *str,int cur,int end){
Token *token=NULL;
int len=0;
len=end-cur;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Delimiter;
if(str[cur]=='.'){
token->subType=TokenSubType_Dot;
}
else if(str[cur]==','){
token->subType=TokenSubType_Comma;
}
else if(str[cur]==':'){
token->subType=TokenSubType_Colon;
}
else if(str[cur]==';'){
token->subType=TokenSubType_Semicolon;
}
else if(str[cur]=='('){
token->subType=TokenSubType_LeftParenth;
}
else if(str[cur]==')'){
token->subType=TokenSubType_RightParenth;
}
else if(str[cur]=='['){
token->subType=TokenSubType_LeftBracket;
}
else if(str[cur]==']'){
token->subType=TokenSubType_RightBracket;
}
else if(str[cur]=='{'){
token->subType=TokenSubType_LeftBrace;
}
else if(str[cur]=='}'){
token->subType=TokenSubType_RightBrace;
}
// else if(str[cur]=='='){
// token->subType=TokenSubType_Assign;
// }
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=len;
return token;
}
static Token *lexOperator(char *str,int cur,int end){
Token *token=NULL;
int len=0;
len=end-cur;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Operator;
if(len==1){
if(str[cur]=='~'){
token->subType=TokenSubType_Reverse;
}
else if(str[cur]=='!'){
token->subType=TokenSubType_Not;
}
else if(str[cur]=='*'){
token->subType=TokenSubType_Mul;
}
else if(str[cur]=='/'){
token->subType=TokenSubType_Div;
}
else if(str[cur]=='%'){
token->subType=TokenSubType_Mod;
}
else if(str[cur]=='+'){
token->subType=TokenSubType_Add;
}
else if(str[cur]=='-'){
token->subType=TokenSubType_Sub;
}
else if(str[cur]=='>'){
token->subType=TokenSubType_GR;
}
else if(str[cur]=='<'){
token->subType=TokenSubType_LS;
}
else if(str[cur]=='|'){
token->subType=TokenSubType_XOr;
}
else if(str[cur]=='&'){
token->subType=TokenSubType_XAnd;
}
else if(str[cur]=='^'){
token->subType=TokenSubType_XEr;
}
else if(str[cur]=='='){
token->subType=TokenSubType_Assign;
}
}
else if(len==2){
if(strncmp(str+cur,"<<",len)==0){
token->subType=TokenSubType_LeftShift;
}
else if(strncmp(str+cur,">>",len)==0){
token->subType=TokenSubType_RightShift;
}
else if(strncmp(str+cur,">=",len)==0){
token->subType=TokenSubType_GE;
}
else if(strncmp(str+cur,"<=",len)==0){
token->subType=TokenSubType_LE;
}
else if(strncmp(str+cur,"==",len)==0){
token->subType=TokenSubType_EQ;
}
else if(strncmp(str+cur,"!=",len)==0){
token->subType=TokenSubType_NE;
}
else if(strncmp(str+cur,"&&",len)==0){
token->subType=TokenSubType_And;
}
else if(strncmp(str+cur,"||",len)==0){
token->subType=TokenSubType_Or;
}
else if(strncmp(str+cur,"*=",len)==0){
token->subType=TokenSubType_MulAssgin;
}
else if(strncmp(str+cur,"/=",len)==0){
token->subType=TokenSubType_DivAssgin;
}
else if(strncmp(str+cur,"%=",len)==0){
token->subType=TokenSubType_ModAssgin;
}
else if(strncmp(str+cur,"+=",len)==0){
token->subType=TokenSubType_AddAssgin;
}
else if(strncmp(str+cur,"-=",len)==0){
token->subType=TokenSubType_SubAssgin;
}
else if(strncmp(str+cur,"|=",len)==0){
token->subType=TokenSubType_XOrAssgin;
}
else if(strncmp(str+cur,"&=",len)==0){
token->subType=TokenSubType_XAndAssgin;
}
else if(strncmp(str+cur,"^=",len)==0){
token->subType=TokenSubType_XErAssgin;
}
}
else if(len==3){
if(strncmp(str+cur,"<<=",len)==0){
token->subType=TokenSubType_LeftShiftAssgin;
}
else if(strncmp(str+cur,">>=",len)==0){
token->subType=TokenSubType_RightShiftAssgin;
}
}
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=len;
return token;
}
static Token *lexKeyword(char *str,int cur,int end){
Token *token=NULL;
int len=0;
len=end-cur;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Keyword;
if(len==2){
if(strncmp(str+cur, "if", len)==0){
token->subType=TokenSubType_If;
}
else if(strncmp(str+cur, "in", len)==0){
token->subType=TokenSubType_In;
}
else if(strncmp(str+cur, "is", len)==0){
token->subType=TokenSubType_Is;
}
else if(strncmp(str+cur, "up", len)==0){
token->subType=TokenSubType_Up;
}
}
else if(len==3){
if(strncmp(str+cur, "def", len)==0){
token->subType=TokenSubType_Def;
}
else if(strncmp(str+cur, "new", len)==0){
token->subType=TokenSubType_New;
}
else if(strncmp(str+cur, "for", len)==0){
token->subType=TokenSubType_For;
}
else if(strncmp(str+cur, "var", len)==0){
token->subType=TokenSubType_Var;
}
else if(strncmp(str+cur, "out", len)==0){
token->subType=TokenSubType_Out;
}
}
else if(len==4){
if(strncmp(str+cur, "self", len)==0){
token->subType=TokenSubType_Self;
}
else if(strncmp(str+cur, "base", len)==0){
token->subType=TokenSubType_Base;
}
else if(strncmp(str+cur, "else", len)==0){
token->subType=TokenSubType_Else;
}
}
else if(len==5){
if(strncmp(str+cur, "class", len)==0){
token->subType=TokenSubType_Class;
}
else if(strncmp(str+cur, "super", len)==0){
token->subType=TokenSubType_Super;
}
else if(strncmp(str+cur, "while", len)==0){
token->subType=TokenSubType_While;
}
else if(strncmp(str+cur, "break", len)==0){
token->subType=TokenSubType_Break;
}
else if(strncmp(str+cur, "field", len)==0){
token->subType=TokenSubType_Field;
}
else if(strncmp(str+cur, "yield", len)==0){
token->subType=TokenSubType_Yield;
}
else if(strncmp(str+cur, "print", len)==0){
token->subType=TokenSubType_Print;
}
}
else if(len==6){
if(strncmp(str+cur, "return", len)==0){
token->subType=TokenSubType_Return;
}
else if(strncmp(str+cur, "static", len)==0){
token->subType=TokenSubType_Static;
}
else if(strncmp(str+cur, "global", len)==0){
token->subType=TokenSubType_Global;
}
else if(strncmp(str+cur, "import", len)==0){
token->subType=TokenSubType_Import;
}
}
else if(len==7){
if(strncmp(str+cur, "declare", len)==0){
token->subType=TokenSubType_Declare;
}
else if(strncmp(str+cur, "include", len)==0){
token->subType=TokenSubType_Include;
}
}
else if(len==8){
if(strncmp(str+cur, "continue", len)==0){
token->subType=TokenSubType_Continue;
}
else if(strncmp(str+cur, "instance", len)==0){
token->subType=TokenSubType_Instance;
}
}
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=len;
return token;
}
static Token *lexIdentify(char *str,int cur,int end){
Token *token=NULL;
int len=0;
len=end-cur;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Identify;
token->data=(char *)calloc(len+1,sizeof(char ));
strncpy(token->data,str+cur,len);
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=len;
return token;
}
static Token *lexLiteral(char *str,int cur,int end){
Token *token=NULL;
int len=0;
len=end-cur;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Literal;
if(__isTrue(str, cur)){
token->subType=TokenSubType_True;
}
else if(__isFalse(str, cur)){
token->subType=TokenSubType_False;
}
else if(__isNull(str, cur)){
token->subType=TokenSubType_Null;
}
else if(__isString(str, cur)){
int _flag=0;
char *_str=NULL;
token->subType=TokenSubType_String;
_str=(char *)calloc(len+1,sizeof(char ));
strncpy(_str,str+cur,len);
_flag=__lexString(_str, &token->data);
free(_str);
if(!token->data){
free(token);
return NULL;
}
}
else if(__isNumber(str, cur)){
int _flag=0;
char *_str=NULL;
_str=(char *)calloc(len+1,sizeof(char ));
strncpy(_str,str+cur,len);
if(__isInt(_str)){
long long v=0;
token->subType=TokenSubType_Int;
_flag=__lexInt(_str, &v);
token->value.l=v;
}
else if(__isFloat(_str)){
double v=0;
token->subType=TokenSubType_Float;
_flag=__lexFloat(_str, &v);
token->value.d=v;
}
free(_str);
if(!_flag){
free(token);
return NULL;
}
}
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=len;
return token;
}
static Token *lexComment(char *str,int cur,int end){
Token *token=NULL;
token=(Token *)calloc(1, sizeof(Token ));
token->type=TokenType_Comment;
token->row=__lex_curRow;
token->column=__lex_curCol;
__lex_curCol+=(end-cur);
return token;
}
static int __isComment(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='#'){
cur++;
while(cur<__lex_strLen){
if(str[cur]=='\n'){
break;
}
cur++;
}
offset=cur;
}
return offset;
}
static int __isIdentify(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='_'||
(str[cur]>='a'&&str[cur]<='z')||
(str[cur]>='A'&&str[cur]<='Z')){
cur++;
for(int i=cur;i<__lex_strLen;i++){
if(!(str[i]=='_'||
(str[i]>='a'&&str[i]<='z')||
(str[i]>='A'&&str[i]<='Z')||
(str[i]>='0'&&str[i]<='9'))){
cur=i;
break;
}
}
offset=cur;
}
return offset;
}
static int __isDelimiter(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='.'||str[cur]==','||
str[cur]==':'||str[cur]==';'||
str[cur]=='('||str[cur]==')'||
str[cur]=='['||str[cur]==']'||
str[cur]=='{'||str[cur]=='}'||
str[cur]=='='){
offset=cur+1;
}
return offset;
}
static int __isKeyword(char *str,int cur){
int offset=0;
int flag1=0;
int len=0;
flag1=__isIdentify(str,cur);
len=flag1-cur;
if(len==2){
if(strncmp(str+cur, "if", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "in", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "is", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "up", len)==0){
offset=flag1;
}
}
else if(len==3){
if(strncmp(str+cur, "def", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "new", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "for", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "var", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "out", len)==0){
offset=flag1;
}
}
else if(len==4){
if(strncmp(str+cur, "self", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "base", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "else", len)==0){
offset=flag1;
}
}
else if(len==5){
if(strncmp(str+cur, "class", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "super", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "while", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "break", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "field", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "yield", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "print", len)==0){
offset=flag1;
}
}
else if(len==6){
if(strncmp(str+cur, "return", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "static", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "global", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "import", len)==0){
offset=flag1;
}
}
else if(len==7){
if(strncmp(str+cur, "declare", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "include", len)==0){
offset=flag1;
}
}
else if(len==8){
if(strncmp(str+cur, "continue", len)==0){
offset=flag1;
}
else if(strncmp(str+cur, "instance", len)==0){
offset=flag1;
}
}
return offset;
}
static int __isOperator(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='~'||str[cur]=='*'||
str[cur]=='/'||str[cur]=='%'||
str[cur]=='^'||str[cur]=='+'||
str[cur]=='-'){
offset=cur+1;
if(cur+2<=__lex_strLen){
if(strncmp(str+cur,"*=",2)==0){
offset++;
}
else if(strncmp(str+cur,"/=",2)==0){
offset++;
}
else if(strncmp(str+cur,"%>",2)==0){
offset++;
}
else if(strncmp(str+cur,"^=",2)==0){
offset++;
}
else if(strncmp(str+cur,"+=",2)==0){
offset++;
}
else if(strncmp(str+cur,"-=",2)==0){
offset++;
}
}
}
else if(str[cur]=='!'||str[cur]=='>'||
str[cur]=='<'||str[cur]=='&'||
str[cur]=='|'){
offset=cur+1;
if(cur+2<=__lex_strLen){
if(strncmp(str+cur,"!=",2)==0){
offset++;
}
else if(strncmp(str+cur,">=",2)==0){
offset++;
}
else if(strncmp(str+cur,">>",2)==0){
offset++;
if(cur+3<=__lex_strLen){
if(strncmp(str+cur,">>=",3)==0){
offset++;
}
}
}
else if(strncmp(str+cur,"<=",2)==0){
offset++;
}
else if(strncmp(str+cur,"<<",2)==0){
offset++;
if(cur+3<=__lex_strLen){
if(strncmp(str+cur,"<<=",3)==0){
offset++;
}
}
}
else if(strncmp(str+cur,"&&",2)==0){
offset++;
}
else if(strncmp(str+cur,"||",2)==0){
offset++;
}
else if(strncmp(str+cur,"&=",2)==0){
offset++;
}
else if(strncmp(str+cur,"|=",2)==0){
offset++;
}
}
}
else if(str[cur]=='='){
offset=cur+1;
if(cur+2<=__lex_strLen){
if(strncmp(str+cur,"==",2)==0){
offset=cur+2;
}
}
}
return offset;
}
static int __isLiteral(char *str,int cur){
int offset=0;
int flag1=0;
flag1=__isNumber(str, cur);
if(flag1){
return flag1;
}
flag1=__isString(str, cur);
if(flag1){
return flag1;
}
flag1=__isTrue(str, cur);
if(flag1){
return flag1;
}
flag1=__isFalse(str, cur);
if(flag1){
return flag1;
}
flag1=__isNull(str, cur);
if(flag1){
return flag1;
}
return offset;
}
static int __isDigit(char *str,int cur){
int offset=0;
cur++;
if(cur>=__lex_strLen){
return cur;
}
while(str[cur]>='0'&&str[cur]<='9'){
cur++;
if(cur>=__lex_strLen){
break;
}
}
offset=cur;
return offset;
}
static int __isDotDigit(char *str,int cur){
int offset=0;
cur++;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]>='0'&&str[cur]<='9'){
offset=__isDigit(str,cur);
}
return offset;
}
// ???
static int __isNumber(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='0'){ // 0
cur++;
}
else if(str[cur]>='1'&&str[cur]<='9'){ // [1-9]
cur=__isDigit(str,cur);
}
else{
return offset;
}
if(cur>=__lex_strLen){ // right
return cur;
}
if(str[cur]=='.'){
cur=__isDotDigit(str,cur);
if(cur==0){
return offset;
}
}
if(cur>=__lex_strLen){ // right
return cur;
}
offset=cur;
return offset;
}
static int __isInt(char *str){
int flag=1;
int i=0;
while(str[i]!='\0'){
if(str[i]=='.'){
flag=0;
break;
}
i++;
}
return flag;
}
static int __isFloat(char *str){
int flag=0;
int i=0;
while(str[i]!='\0'){
if(str[i]=='.'){
flag=1;
break;
}
i++;
}
return flag;
}
static int __isString(char *str,int cur){
int offset=0;
if(cur>=__lex_strLen){
return 0;
}
if(str[cur]=='\"'){
cur++;
for(int i=cur;i<__lex_strLen;i++){
if(str[i]=='\"'&&str[i-1]!='\\'){
offset=i+1;
break;
}
}
}
return offset;
}
static int __isTrue(char *str,int cur){
int offset=0;
int flag1=0;
flag1=__isIdentify(str,cur);
if(flag1-cur==4){
if(strncmp(str+cur, "true", 4)==0){
offset=flag1;
}
}
return offset;
}
static int __isFalse(char *str,int cur){
int offset=0;
int flag1=0;
flag1=__isIdentify(str,cur);
if(flag1-cur==4){
if(strncmp(str+cur, "false", 5)==0){
offset=flag1;
}
}
return offset;
}
static int __isNull(char *str,int cur){
int offset=0;
int flag1=0;
flag1=__isIdentify(str,cur);
if(flag1-cur==4){
if(strncmp(str+cur, "null", 4)==0){
offset=flag1;
}
}
return offset;
}
void __freeHeadToken(Token *token){
if(token){
free(token->data);
__freeHeadToken(token->next);
free(token);
}
}
void __freeTailToken(Token *token){
Token *_token=NULL;
while(token){
_token=token->pre;
free(token->data);
free(token);
token=_token;
}
}
void freeToken(Token *token){
if(token){
if(token->pre){
__freeTailToken(token);
}
else if(token->next){
__freeHeadToken(token);
}
else{
free(token->data);
free(token);
}
}
}
|
liufeigit/Van-lang
|
src/van_error.h
|
<gh_stars>1-10
#ifndef VAN_ERROR_H
#define VAN_ERROR_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "van_enum.h"
#include "van_lex.h"
// van_error 相关
typedef struct ErrorInfor{
ErrorType type;
unsigned int row;
unsigned int column;
char *data; // indentify
} ErrorInfor;
void error_throwError(ErrorType type,Token *token);
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_builtin.h
|
<reponame>liufeigit/Van-lang
#ifndef VAN_BUILTIN_H
#define VAN_BUILTIN_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "van_data.h"
#include "van_lex.h"
/***
str1="123";
str1=new String("123");
****/
VanWrap *wrap_setValueWithKey(VanWrap *wrap,char *key,VanWrap *value);
VanWrap *wrap_setValueWithIndex(VanWrap *wrap,int index,VanWrap *value);
VanWrap *wrap_getValueWithKey(VanWrap *wrap,char *key);
VanWrap *wrap_getValueWithIndex(VanWrap *wrap,int index);
VanWrap *wrap_not(VanWrap *wrap);
VanWrap *wrap_reverse(VanWrap *wrap);
VanWrap *wrap_neggative(VanWrap *wrap);
VanWrap *wrap_mul(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_div(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_mod(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_add(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_sub(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_leftShift(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_rightShift(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_gr(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_ge(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_ls(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_le(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_eq(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_ne(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_xor(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_xand(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_xer(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_and(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_or(VanWrap *wrap1,VanWrap *wrap2);
VanWrap *wrap_builtinNumber();
VanWrap *wrap_builtinBoolean();
VanWrap *wrap_builtinString();
VanWrap *wrap_builtinList();
VanWrap *wrap_builtinMap();
VanWrap *wrap_builtinFunction();
VanWrap *wrap_builtinClass();
VanWrap *VanString_new(VanWrap *data);
VanWrap *VanString_length(VanWrap *str);
VanWrap *VanString_add(VanWrap *str1,VanWrap *str2);
VanWrap *VanString_split(VanWrap *str1,VanWrap *data);
VanWrap *VanString_setValue(VanWrap *str,VanWrap *c);
VanWrap *VanString_getValue(VanWrap *str);
VanWrap *VanString_subString(VanWrap *str,VanWrap *start,VanWrap *end);
VanWrap *VanString_toString(VanWrap *str);
VanWrap *VanString_free(VanWrap *str);
VanWrap *VanList_new(VanWrap *length);
VanWrap *VanList_length(VanWrap *list);
VanWrap *VanList_push(VanWrap *list,VanWrap *value);
VanWrap *VanList_pop(VanWrap *list);
VanWrap *VanList_indexOf(VanWrap *list,VanWrap *value);
VanWrap *VanList_lastIndexOf(VanWrap *list,VanWrap *value);
VanWrap *VanList_setValue(VanWrap *list,VanWrap *index,VanWrap *value);
VanWrap *VanList_getValue(VanWrap *list,VanWrap *index);
VanWrap *VanList_toString(VanWrap *list);
VanWrap *VanList_free(VanWrap *list);
VanWrap *VanMap_new();
VanWrap *VanMap_length(VanWrap *map);
VanWrap *VanMap_setValue(VanWrap *map,VanWrap *key,VanWrap *value);
VanWrap *VanMap_getValue(VanWrap *map,VanWrap *key);
VanWrap *VanMap_hasKey(VanWrap *map,VanWrap *key);
VanWrap *VanMap_keyArr(VanWrap *map);
VanWrap *VanMap_valueArr(VanWrap *map);
VanWrap *VanMap_toString(VanWrap *map);
VanWrap *VanMap_free(VanWrap *map);
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_environBridge.c
|
// clang
#include <dirent.h>
#include <dlfcn.h>
#include "van_environ.h"
void environ_initDynamic(VanEnviron *env){
char *dirName="./External/";
DIR *dp=NULL;
struct dirent *dirp=NULL;
void *fp=NULL;
void *handler=NULL;
char *filePath=NULL;
dp=opendir(dirName);
if(dp){
while((dirp = readdir(dp)) != NULL){
if(dirp->d_type!=DT_DIR){
int _len1=strlen(dirName);
int _len2=strlen(dirp->d_name);
filePath=(char *)calloc(_len1+_len2+1,sizeof(char ));
strcpy(filePath,dirName);
strcpy(filePath+_len1,dirp->d_name);
fp=dlopen(filePath, RTLD_NOW);
if(fp){
handler=dlsym(fp, "nativeFunction_Load");
if(handler){
void (*fc1)(VanEnviron *)=handler;
fc1(env);
printf("initDynamic is -----%s\n",dirp->d_name);
}
}
free(filePath);
// dlclose(fp);
}
}
}
closedir(dp);
}
void environ_brigeNativeFunction(VanEnviron *env,VanFunction *func){
VanWrap *nativeWrap=NULL;
char *name=NULL;
name=func->name;
nativeWrap=wrap_wrapFunction(func);
map_setValue(env->scopeDict, name, nativeWrap);
}
void environ_brigeNativeClass(VanEnviron *env,VanClass *cls){
VanWrap *nativeWrap=NULL;
char *name=NULL;
name=cls->name;
nativeWrap=wrap_wrapClass(cls);
map_setValue(env->scopeDict, name, nativeWrap);
}
/***
Number
a=new Number("1.23"|1|null|true|false);
a.toString();
Boolean
a=new Boolean(true|false|""|null|0)
Null
a=new Null();
String
a=new String(""|1|true|false|null)
Map
a=new Map();
List
a=new List(100);
Function
a=new Function("","");
Class->Type
a=new Type("",base);
****/
void environ_initBuiltin(VanEnviron *env){
VanClass *cls=NULL;
cls=wrap_createListClass();
environ_brigeNativeClass(env,cls);
cls=wrap_createMapClass();
environ_brigeNativeClass(env,cls);
}
|
liufeigit/Van-lang
|
src/van_gen.h
|
#ifndef VAN_GEN_H
#define VAN_GEN_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include "van_enum.h"
#include "van_parse.h"
// add a
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/enum/van_lexEnum.h
|
#ifndef VAN_LEXENUM_H
#define VAN_LEXENUM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum {
TokenType_Comment=1,
TokenType_Identify,
TokenType_Keyword,
TokenType_Literal,
TokenType_Operator,
TokenType_Delimiter
} TokenType;
typedef enum {
// keyword
TokenSubType_If=1,
TokenSubType_In,
TokenSubType_Is,
TokenSubType_Up,
TokenSubType_Def,
TokenSubType_New,
TokenSubType_For,
TokenSubType_Var,
TokenSubType_Out,
TokenSubType_End,
TokenSubType_Ref,
TokenSubType_Self,
TokenSubType_Base,
TokenSubType_Else,
TokenSubType_Class,
TokenSubType_Super,
TokenSubType_While,
TokenSubType_Break,
TokenSubType_Field,
TokenSubType_Yield,
TokenSubType_Print, // 测试
TokenSubType_Return,
TokenSubType_Static,
TokenSubType_Global,
TokenSubType_Import,
TokenSubType_Export,
TokenSubType_Extern,
TokenSubType_Declare,
TokenSubType_Include,
TokenSubType_Nataive,
TokenSubType_Continue,
TokenSubType_Instance,
// literal
TokenSubType_String,
// TokenSubType_Number,
TokenSubType_Int,
TokenSubType_Float,
TokenSubType_True,
TokenSubType_False,
TokenSubType_Null,
// delimiter .,:;()[]{} ()[]{}<>''"".,;:`~!@#$^& =?_|
TokenSubType_LeftParenth, // '('
TokenSubType_RightParenth,
TokenSubType_LeftBracket, // '['
TokenSubType_RightBracket,
TokenSubType_LeftBrace, // '{'
TokenSubType_RightBrace,
TokenSubType_Dot, // '.'
TokenSubType_Comma, // ','
TokenSubType_Colon, // ':'
TokenSubType_Semicolon, // ';'
TokenSubType_AssignStart,
TokenSubType_Assign, // '='
TokenSubType_MulAssgin, // *=
TokenSubType_DivAssgin, // /=
TokenSubType_ModAssgin, // %=
TokenSubType_AddAssgin, // +=
TokenSubType_SubAssgin, // -=
TokenSubType_LeftShiftAssgin, // <<=
TokenSubType_RightShiftAssgin, // >>=
TokenSubType_XOrAssgin, // |=
TokenSubType_XAndAssgin, // &=
TokenSubType_XErAssgin, // ^=
TokenSubType_AssignEnd,
TokenSubType_LeftAngle, // '<'
TokenSubType_RightAngle,
TokenSubType_At, // '@'
TokenSubType_Single, // ' ' '
TokenSubType_Double, // ' " '
TokenSubType_Sharp, // '#'
TokenSubType_Slash, // '/'
TokenSubType_Escape, // '\'
TokenSubType_Bar, // '|'
TokenSubType_Underline, // '_'
TokenSubType_Grave, // '`'
TokenSubType_Question, // '?'
TokenSubType_Doller, // '$'
TokenSubType_Ampersand, // '&'
TokenSubType_Caret, // '^'
TokenSubType_Tilde, // '~'
// operator +-*/% &&||! |&^~<<>> >>=<<
TokenSubType_Reverse, // ~
TokenSubType_Not, // !
TokenSubType_BinaryStart=100,
TokenSubType_Mul=101, // *
TokenSubType_Div=111, // /
TokenSubType_Mod=121, // %
TokenSubType_Add=102, // +
TokenSubType_Sub=112, // -
TokenSubType_LeftShift=103, // <<
TokenSubType_RightShift=113, // >>
TokenSubType_GR=104, // >
TokenSubType_GE=114, // >=
TokenSubType_LS=124, // <
TokenSubType_LE=134, // <=
TokenSubType_EQ=105, // ==
TokenSubType_NE=115, // !=
TokenSubType_XOr=106, // |
TokenSubType_XAnd=116, // &
TokenSubType_XEr=126, // ^
TokenSubType_And=107, // &&
TokenSubType_Or=117, // ||
TokenSubType_Three=108, // ?
TokenSubType_BinaryEnd=200,
} TokenSubType;
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_type.h
|
#ifndef VAN_TYPE_H
#define VAN_TYPE_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "van_data.h"
// String
VanWrap *VanString_new(VanWrap *self,VanList *arglist);
VanWrap *VanString_length(VanWrap *self,VanList *arglist);
VanWrap *VanString_add(VanWrap *self,VanList *arglist);
VanWrap *VanString_split(VanWrap *self,VanList *arglist);
VanWrap *VanString_setValue(VanWrap *self,VanList *arglist);
VanWrap *VanString_getValue(VanWrap *self,VanList *arglist);
VanWrap *VanString_subString(VanWrap *self,VanList *arglist);
VanWrap *VanString_toString(VanWrap *self,VanList *arglist);
VanWrap *VanString_free(VanWrap *self,VanList *arglist);
// List
VanWrap *VanList_new(VanWrap *self,VanList *arglist);
VanWrap *VanList_length(VanWrap *self,VanList *arglist);
VanWrap *VanList_push(VanWrap *self,VanList *arglist);
VanWrap *VanList_pop(VanWrap *self,VanList *arglist);
VanWrap *VanList_indexOf(VanWrap *self,VanList *arglist);
VanWrap *VanList_lastIndexOf(VanWrap *self,VanList *arglist);
VanWrap *VanList_setValue(VanWrap *self,VanList *arglist);
VanWrap *VanList_getValue(VanWrap *self,VanList *arglist);
VanWrap *VanList_toString(VanWrap *self,VanList *arglist);
VanWrap *VanList_free(VanWrap *self,VanList *arglist);
// Map
VanWrap *VanMap_new(VanWrap *self,VanList *arglist);
VanWrap *VanMap_length(VanWrap *self,VanList *arglist);
VanWrap *VanMap_setValue(VanWrap *self,VanList *arglist);
VanWrap *VanMap_getValue(VanWrap *self,VanList *arglist);
VanWrap *VanMap_hasKey(VanWrap *self,VanList *arglist);
VanWrap *VanMap_keyArr(VanWrap *self,VanList *arglist);
VanWrap *VanMap_valueArr(VanWrap *self,VanList *arglist);
VanWrap *VanMap_toString(VanWrap *self,VanList *arglist);
VanWrap *VanMap_free(VanWrap *self,VanList *arglist);
VanClass *wrap_createStringClass();
VanClass *wrap_createListClass();
VanClass *wrap_createMapClass();
VanClass *wrap_createFunctionClass();
VanClass *wrap_createClassClass();
VanClass *wrap_createMapClass();
VanWrap *wrap_setValueWithKey(VanWrap *wrap,char *key,VanWrap *value);
VanWrap *wrap_setValueWithIndex(VanWrap *wrap,int index,VanWrap *value);
VanWrap *wrap_getValueWithKey(VanWrap *wrap,char *key);
VanWrap *wrap_getValueWithIndex(VanWrap *wrap,int index);
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/enum/van_parseEnum.h
|
#ifndef VAN_PARSENUM_H
#define VAN_PARSENUM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum{
ASTType_Expr=1,
ASTType_Assign,
ASTType_If,
ASTType_While,
ASTType_For,
ASTType_Function,
ASTType_Class,
ASTType_Continue,
ASTType_Break,
ASTType_Return,
ASTType_Up,
ASTType_Global,
ASTType_Field,
ASTType_Static,
ASTType_Import,
ASTType_Yield,
ASTType_Print, // 测试
ASTType_Block,
} ASTType;
typedef enum{
ASTOp_IfTerm=1,
ASTOp_ElseIfTerm,
ASTOp_ForTerm,
ASTOp_WhileTerm,
ASTOp_Comma,
ASTOp_Arguments,
ASTOp_Pair,
ASTOp_Slice,
ASTOp_IfBlock,
ASTOp_IfElseBlock,
ASTOp_ElseBlock,
ASTOp_ForBlock,
ASTOp_WhileBlock,
ASTOp_FunctionBlock,
ASTOp_ClassBlock,
ASTOp_DeclareAssign,
ASTOp_MulAssgin,
ASTOp_DivAssgin,
ASTOp_ModAssgin,
ASTOp_AddAssgin,
ASTOp_SubAssgin,
ASTOp_LeftShiftAssgin,
ASTOp_RightShiftAssgin,
ASTOp_XOrAssgin,
ASTOp_XAndAssgin,
ASTOp_XErAssgin,
ASTOp_Indentify,
// ASTOp_Number,
ASTOp_Int, // long long
ASTOp_Float, // double
ASTOp_Null,
ASTOp_True,
ASTOp_False,
ASTOp_String,
ASTOp_Self,
ASTOp_Super,
ASTOp_Map, // {Indentify:Expr}
ASTOp_List, // [Expr]
ASTOp_FunctionExpr, // def {}
ASTOp_ClassExpr, // class {}
ASTOp_Prior, // (Expr)
ASTOp_Call, // Expr(Expr,...)
ASTOp_Property, // Expr.Indentify
ASTOp_Subscript, // Expr[Number|String]
ASTOp_Not, // !
ASTOp_Reverse, // ~
ASTOp_New, // new Expr
ASTOp_Negative, // -Expr
ASTOp_BinaryStart=100,
ASTOp_Mul=101, // *
ASTOp_Div=111, // /
ASTOp_Mod=121, // %
ASTOp_Add=102, // +
ASTOp_Sub=112, // -
ASTOp_LeftShift=103, // <<
ASTOp_RightShift=113, // >>
ASTOp_GR=104, // >
ASTOp_GE=114, // >=
ASTOp_LS=124, // <
ASTOp_LE=134, // <=
ASTOp_EQ=105, // ==
ASTOp_NE=115, // !=
ASTOp_XOr=106, // |
ASTOp_XAnd=116, // &
ASTOp_XEr=126, // ^
ASTOp_And=107, // &&
ASTOp_Or=117, // ||
ASTOp_Three=108, // ?:
ASTOp_BinaryEnd=200,
} ASTOp;
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/enum/van_errorEnum.h
|
#ifndef VAN_ERRORENUM_H
#define VAN_ERRORENUM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// van_error 相关
typedef enum {
ErrorType_LexError=1, // 词法错误
ErrorType_ExprSyntaxError, // 语法错误
ErrorType_AssignSyntaxError,
ErrorType_ContinueSyntaxError,
ErrorType_BreakSyntaxError,
ErrorType_ReturnSyntaxError,
ErrorType_UpSyntaxError,
ErrorType_GlobalSyntaxError,
ErrorType_FieldSyntaxError,
ErrorType_YieldSyntaxError,
ErrorType_StaticSyntaxError,
ErrorType_ImportSyntaxError,
ErrorType_PrintSyntaxError,
ErrorType_IfSyntaxError,
ErrorType_WhileSyntaxError,
ErrorType_ForSyntaxError,
ErrorType_FunctionSyntaxError,
ErrorType_ClassSyntaxError,
ErrorType_SubscriptError, // 语义错误
ErrorType_PropertyError,
ErrorType_CallError,
ErrorType_NewError,
ErrorType_OperateError,
} ErrorType;
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_enum.h
|
<filename>src/van_enum.h
#ifndef VAN_ENUM_H
#define VAN_ENUM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "./enum/van_errorEnum.h"
#include "./enum/van_lexEnum.h"
#include "./enum/van_parseEnum.h"
#include "./enum/van_dataEnum.h"
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_environ.h
|
#ifndef VAN_ENVIRON_H
#define VAN_ENVIRON_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include "van_data.h"
#include "van_type.h"
#include "van_parse.h"
#include "van_parseUtil.h"
typedef struct {
VanMap *scopeDict; // var/function/class
VanMap *curScope;
VanWrap *curBindObj; // self cls/ins
VanInstance *curIns; // self
VanList *callStack; // function call stack
VanList *instanceStack;
VanWrap *returnValue; // return/break/continue
int isReturn;
int isBreak;
int isContinue;
} VanEnviron;
// environ
/***
environ_setScopeValue
environ_getScopeValue
environ_eval
****/
VanEnviron *environ_create();
void environ_addNameSapce(VanEnviron *env,char *str);
void environ_importNameSapce(VanEnviron *env,char *str);
void environ_init(VanEnviron *env);
void environ_initStatic(VanEnviron *env);
void environ_initDynamic(VanEnviron *env);
void environ_initBuiltin(VanEnviron *env);
void environ_brigeNativeFunction(VanEnviron *env,VanFunction *func);
void environ_brigeNativeClass(VanEnviron *env,VanClass *cls);
void environ_eval(VanEnviron *env,ASTNode *astNode);
void environ_evalStr(VanEnviron *env,char *str);
void environ_free(VanEnviron *env);
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_parse.c
|
// clang
#include "van_parse.h"
#include "van_lexUtil.h"
#include "van_parseUtil.h"
static Token *parseState(Token *token, ASTNode **node);
static Token *parseBlock(Token *start,Token *end,ASTNode **node);
static Token *parseExprState(Token *token, ASTNode **node);
static Token *parseAssignState(Token *token,ASTNode **node);
static Token *parseIfState(Token *token,ASTNode **node);
static Token *parseWhileState(Token *token,ASTNode **node);
static Token *parseForState(Token *token,ASTNode **node);
static Token *__parseForInState(Token *token,Token *inToken,ASTNode **node);
static Token *__parseForThreeState(Token *token,ASTNode **node);
static Token *parseFunctionState(Token *token,ASTNode **node);
static Token *parseClassState(Token *token,ASTNode **node);
static Token *parseContinueState(Token *token,ASTNode **node);
static Token *parseBreakState(Token *token,ASTNode **node);
static Token *parseReturnState(Token *token,ASTNode **node);
static Token *parseYieldState(Token *token,ASTNode **node);
// flag 0 expr 1 state
static Token *__parseArguments(Token *token,int flag,ASTNode **node);
// flag 0 right 1 left 2 for
static Token *__parseComma(Token *token,Token *end,int flag,ASTNode **node);
// static Token *__parseFunction(Token *token,int flag,ASTNode **node);
// static Token *__parseClass(Token *token,int flag,ASTNode **node);
static Token *parseArguments(Token *token,ASTNode **node);
static Token *parseUpState(Token *token,ASTNode **node);
static Token *parseGlobalState(Token *token,ASTNode **node);
static Token *parseFieldState(Token *token,ASTNode **node);
static Token *parseStaticState(Token *token,ASTNode **node);
static Token *parseImportState(Token *token,ASTNode **node);
static Token *parsePrintState(Token *token,ASTNode **node);
static Token *__parseSemState(Token *token,ASTNode **node,ASTType type,int flag);
static Token *parseExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node);
static Token *__parseOpenExpr(Token *token,Token *terminal, ASTNode **node);
static Token *__parseReduceExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node);
static Token *__parseIncompleteExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node);
static Token *parseMap(Token *start, ASTNode **node);
static Token *parseList(Token *start, ASTNode **node);
static Token *parseFunctionExpr(Token *token,ASTNode **node);
static Token *parseClassExpr(Token *token,ASTNode **node);
static Token *parseArgumentsExpr(Token *token,ASTNode **node);
static Token *parsePair(Token *token,Token *tail, ASTNode **node);
static Token *parseCall(Token *token,ASTNode *preNode,ASTNode **node);
static Token *parseProperty(Token *token,ASTNode *preNode,ASTNode **node);
static Token *parseSubscript(Token *token,ASTNode *preNode,ASTNode **node);
static Token *parseIdentifi(Token *token ,ASTNode **node);
static Token *parseNumber(Token *token,ASTNode **node);
static Token *parseNull(Token *token,ASTNode **node);
static Token *parseTrue(Token *token,ASTNode **node);
static Token *parseFalse(Token *token,ASTNode **node);
static Token *parseSelf(Token *token,ASTNode **node);
static Token *parseSuper(Token *token,ASTNode **node);
static Token *parseStringExpr(Token *token,ASTNode **node);
static Token *parsePrior(Token *token,ASTNode **node);
static Token *parseMono(Token *token,Token *terminal,ASTNode **node);
static Token *parseNegative(Token *token,Token *terminal,ASTNode **node);
static Token *parseNew(Token *token,Token *terminal,ASTNode **node);
static Token *parseReverse(Token *token,Token *terminal,ASTNode **node);
static Token *parseNot(Token *token,Token *terminal,ASTNode **node);
int parseToken(Token *token,ASTNode **node){
int status=0;
int flag=1;
ASTNode *head=NULL;
ASTNode *cur=NULL;
token=filterEmpty(token);
token=parseState(token,&head);
cur=head;
token=filterEmpty(token);
while(token){
ASTNode *_cur=NULL;
token=parseState(token,&_cur);
if(!_cur){
flag=0;
freeASTNode(_cur);
break;
}
cur->next=_cur;
cur=cur->next;
token=filterEmpty(token);
}
if(flag){
*node=head;
}
else{
freeASTNode(head);
}
return status;
}
static Token *parseMap(Token *token, ASTNode **node){
Token *end=NULL;
Token *tail=NULL;
Token *split=NULL;
ASTNode *cur=NULL;
ASTNode *elemet=NULL;
ASTNode **nodeArr=NULL;
int length=0;
int len=0;
end=__boundMapExpr(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Map;
length=__calListLength(token,end);
if(length){
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
token=token->next;
tail=end;
while(token!=end){
split=__boundComma(token,end);
if(split){
tail=parsePair(token,split,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(cur);
for(int i=0;i<len;i++){
freeASTNode(nodeArr[i]);
}
free(nodeArr);
freeASTNode(elemet);
return NULL;
}
token=split->next;
}
else{
tail=parsePair(token,end,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(cur);
for(int i=0;i<len;i++){
freeASTNode(nodeArr[i]);
}
free(nodeArr);
freeASTNode(elemet);
return NULL;
}
token=end;
}
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
}
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
end=end->next;
return end;
}
static Token *parseList(Token *token, ASTNode **node){
Token *end=NULL;
Token *tail=NULL;
Token *split=NULL;
ASTNode *cur=NULL;
ASTNode *elemet=NULL;
ASTNode **nodeArr=NULL;
int length=0;
int len=0;
end=__boundListExpr(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_List;
length=__calListLength(token,end);
if(length){
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
token=token->next;
while(token!=end){
split=__boundComma(token,end);
if(split){
tail=parseExpr(token,split,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(cur);
for(int i=0;i<len;i++){
freeASTNode(nodeArr[i]);
}
free(nodeArr);
freeASTNode(elemet);
return NULL;
}
token=split->next;
}
else{
tail=parseExpr(token,end,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(cur);
for(int i=0;i<len;i++){
freeASTNode(nodeArr[i]);
}
free(nodeArr);
freeASTNode(elemet);
return NULL;
}
token=end;
}
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
}
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
end=end->next;
return end;
}
static Token *parseFunctionExpr(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *functionNode=NULL;
ASTNode *nameNode=NULL;
ASTNode *argNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundFunctionState(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
start=token->next;
functionNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
functionNode->type=ASTType_Expr;
functionNode->op=ASTOp_FunctionExpr;
functionNode->childLength=3;
functionNode->childArr=(ASTNode **)calloc(3, sizeof(ASTNode *));
if(start->subType==TokenSubType_LeftBrace){ // block
end=parseBlock(start, end, &blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(functionNode);
freeASTNode(blockNode);
return NULL;
}
if(end){
functionNode->childArr[2]=blockNode;
blockNode->op=ASTOp_FunctionBlock;
blockNode->parent=functionNode;
*node=functionNode;
return end;
}
}
else if(start->subType==TokenSubType_LeftParenth){ // arg
_token=start;
start=parseArguments(start, &argNode);
if(!start){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(functionNode);
freeASTNode(argNode);
return NULL;
}
if(start->subType==TokenSubType_LeftBrace){ // block
end=parseBlock(start, end, &blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(functionNode);
freeASTNode(argNode);
freeASTNode(blockNode);
return NULL;
}
if(end){
functionNode->childArr[1]=argNode;
argNode->parent=functionNode;
functionNode->childArr[2]=blockNode;
blockNode->op=ASTOp_FunctionBlock;
blockNode->parent=functionNode;
*node=functionNode;
return end;
}
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(functionNode);
freeASTNode(argNode);
freeASTNode(blockNode);
return NULL;
}
// Class={Name,Expr,ClassBlock}
static Token *parseClassExpr(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *classNode=NULL;
ASTNode *nameNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundClassState(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
start=token->next;
classNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
classNode->type=ASTType_Expr;
classNode->op=ASTOp_ClassExpr;
classNode->childLength=3;
classNode->childArr=(ASTNode **)calloc(3, sizeof(ASTNode *));
if(start->subType==TokenSubType_LeftParenth||
start->subType==TokenSubType_LeftBrace){ // (||{
if(start->subType==TokenSubType_LeftParenth){
Token *_end=NULL;
_end=__boundParenth(start);
if(!_end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(classNode);
return NULL;
}
if(start->next!=_end){
_token=start->next;
start=parseExpr(start->next, _end,NULL,&exprNode);
if(!start){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(classNode);
freeASTNode(exprNode);
return NULL;
}
}
else{
start=start->next;
}
start=start->next;
}
if(start->subType==TokenSubType_LeftBrace){ // block
end=__boundBrace(start);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(classNode);
freeASTNode(exprNode);
return NULL;
}
end=parseBlock(start, end, &blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(classNode);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
if(end){
if(exprNode){
classNode->childArr[1]=exprNode;
exprNode->parent=classNode;
}
classNode->childArr[2]=blockNode;
blockNode->op=ASTOp_ClassBlock;
blockNode->parent=classNode;
*node=classNode;
return end;
}
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(classNode);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
static Token *__parseOpenExpr(Token *token,Token *terminal, ASTNode **node){
Token *end=NULL;
Token *error=token;
if(__isIdentifiExpr(token)){
end=parseIdentifi(token,node);
}
else if(__isNumberExpr(token)){
end=parseNumber(token,node);
}
else if(__isNullExpr(token)){
end=parseNull(token,node);
}
else if(__isTrueExpr(token)){
end=parseTrue(token,node);
}
else if(__isFalseExpr(token)){
end=parseFalse(token,node);
}
else if(__isSelfExpr(token)){
end=parseSelf(token,node);
}
else if(__isSuperExpr(token)){
end=parseSuper(token,node);
}
else if(__isStringExpr(token)){
end=parseStringExpr(token,node);
}
else if(__isMapExpr(token)){
end=parseMap(token,node);
}
else if(__isListExpr(token)){
end=parseList(token,node);
}
else if(__isFunctionExpr(token)){
end=parseFunctionExpr(token,node);
}
else if(__isClassExpr(token)){
end=parseClassExpr(token,node);
}
else if(__isPriorExpr(token)){
end=parsePrior(token,node);
}
else if(__isNegativeExpr(token)){
end=parseNegative(token,terminal,node);
}
else if(__isNewExpr(token)){
end=parseNew(token,terminal,node);
}
else if(__isReverseExpr(token)){
end=parseReverse(token,terminal,node);
}
else if(__isNotExpr(token)){
end=parseNot(token,terminal,node);
}
else{ // error
}
// if(!end){
// error_throwError(ErrorType_ExprSyntaxError, error);
// }
return end;
}
static Token *__parseIncompleteExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
TokenSubType curSubType=0;
ASTOp op=0;
Token *error=token;
if(token!=terminal){ // right 递归
curSubType=token->subType;
if(curSubType>TokenSubType_BinaryStart&&
curSubType<TokenSubType_BinaryEnd){
op=(ASTOp )curSubType;
}
}
if(op){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->op=op;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
curNode->childArr[0]=preNode;
*node=curNode;
end=token->next;
return end;
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(curNode);
return NULL;
}
static Token *__parseReduceExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
TokenSubType curSubType=0;
Token *_token=NULL;
while(token!=terminal){
curSubType=token->subType;
if(curSubType==TokenSubType_LeftParenth||
curSubType==TokenSubType_Dot||
curSubType==TokenSubType_LeftBracket){ // left 归约
_token=token;
if(curSubType==TokenSubType_LeftParenth){ // Expr(Arguments)
token=parseCall(token, preNode, &curNode);
}
else if(curSubType==TokenSubType_Dot){ // Expr.Identifi
token=parseProperty(token, preNode, &curNode);
}
else { // Expr[Expr]
token=parseSubscript(token, preNode, &curNode);
}
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(curNode);
return NULL;
}
preNode=curNode;
continue;
}
else{
curNode=preNode;
break;
}
}
*node=curNode;
end=token;
return end;
}
/***
parseExpr
1. open 起始可终结
2. reduce 归约可终结
3. incomplete 不完全不可终结
1. parseExpr=open
2. parseExpr=open+reduce
3. parseExpr=open+reduce+incomplete+parseExpr
****/
static Token *parseExpr(Token *token,Token *terminal,ASTNode *preNode, ASTNode **node){
Token *end=NULL;
ASTNode *openNode=NULL;
ASTNode *reduceNode=NULL;
ASTNode *incometNode=NULL;
Token *error=token;
Token *_token=NULL;
// 1.
_token=token;
token=__parseOpenExpr(token,terminal,&openNode);
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(openNode);
return NULL;
}
if(token&&token==terminal){
*node=astNode_mergeNode(preNode,openNode);
return terminal;
}
// 2.
_token=token;
token=__parseReduceExpr(token,terminal, openNode,&reduceNode);
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(openNode);
freeASTNode(reduceNode);
return NULL;
}
if(token&&token==terminal){
*node=astNode_mergeNode(preNode,reduceNode);
return terminal;
}
// 3.
_token=token;
token=__parseIncompleteExpr(token,terminal, reduceNode,&incometNode);
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(openNode);
freeASTNode(reduceNode);
freeASTNode(incometNode);
return NULL;
}
if(token){
preNode=astNode_mergeNode(preNode,incometNode);
end=parseExpr(token,terminal,preNode,node);
}
if(end!=terminal){
end=NULL;
}
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(openNode);
freeASTNode(reduceNode);
freeASTNode(incometNode);
freeASTNode(*node);
*node=NULL;
}
return end;
}
static Token *parsePair(Token *token,Token *tail, ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
ASTNode *keyNode=NULL;
ASTNode *valueNode=NULL;
Token *error=token;
if(token->type==TokenType_Identify){ // String ???
// keyNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
// keyNode->type=ASTType_Expr;
// keyNode->op=ASTOp_Indentify;
// keyNode->data=(char *)calloc(strlen(token->data)+1, sizeof(char ));
// strcpy(keyNode->data,token->data);
end=parseExpr(token, token->next, NULL, &keyNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(keyNode);
return NULL;
}
if(token->next->subType==TokenSubType_Colon){
end=parseExpr(token->next->next, tail, NULL,&valueNode);
if(!end){
error_throwError(ErrorType_ExprSyntaxError, token->next->next);
freeASTNode(keyNode);
freeASTNode(valueNode);
return NULL;
}
if(end==tail){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
curNode->childArr[0]=keyNode;
curNode->childArr[1]=valueNode;
keyNode->parent=curNode;
valueNode->parent=curNode;
*node=curNode;
end=end->next;
return end;
}
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(keyNode);
freeASTNode(valueNode);
freeASTNode(curNode);
return NULL;
}
static Token *parseArgumentsExpr(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseArguments(token,0,node);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(*node);
*node=NULL;
}
return end;
}
static Token *parseCall(Token *token,ASTNode *preNode,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
ASTNode *argNode=NULL;
Token *error=token;
end=__boundParenth(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
if(end){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->op=ASTOp_Call;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
end=parseArgumentsExpr(token, &argNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(curNode);
freeASTNode(argNode);
return NULL;
}
if(end){
curNode->childArr[0]=preNode;
curNode->childArr[1]=argNode;
preNode->parent=curNode;
argNode->parent=curNode;
*node=curNode;
return end;
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(curNode);
freeASTNode(argNode);
return NULL;
}
static Token *parseProperty(Token *token,ASTNode *preNode,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
ASTNode *propertyNode=NULL;
Token *error=token;
if(token->next){
if(token->next->type==TokenType_Identify){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->op=ASTOp_Property;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
end=parseIdentifi(token->next,&propertyNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token->next);
freeASTNode(curNode);
freeASTNode(propertyNode);
return NULL;
}
if(end){
curNode->childArr[0]=preNode;
curNode->childArr[1]=propertyNode;
preNode->parent=curNode;
propertyNode->parent=curNode;
*node=curNode;
return end;
}
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(curNode);
freeASTNode(propertyNode);
return NULL;
}
static Token *parseSubscript(Token *token,ASTNode *preNode,ASTNode **node){
Token *end=NULL;
Token *tail=NULL;
ASTNode *curNode=NULL;
ASTNode *subNode=NULL;
Token *error=token;
end=__boundBracket(token);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
tail=end;
if(end){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->op=ASTOp_Subscript;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
end=parseExpr(token->next, tail, NULL, &subNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token->next);
freeASTNode(curNode);
freeASTNode(subNode);
return NULL;
}
if(end==tail){
curNode->childArr[0]=preNode;
curNode->childArr[1]=subNode;
preNode->parent=curNode;
subNode->parent=curNode;
*node=curNode;
end=end->next;
return end;
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(curNode);
freeASTNode(subNode);
return NULL;
}
static Token *parseIdentifi(Token *token ,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
int len=0;
len=strlen(token->data)+1;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Indentify;
cur->data=(char *)calloc(len, sizeof(char ));
strcpy(cur->data, token->data);
*node=cur;
end=token->next;
return end;
}
static Token *parseNumber(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
if(token->subType==TokenSubType_Int){
cur->op=ASTOp_Int;
cur->value.l=token->value.l;
}
else if(token->subType==TokenSubType_Float){
cur->op=ASTOp_Float;
cur->value.d=token->value.d;
}
*node=cur;
end=token->next;
return end;
}
static Token *parseNull(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
int len=0;
len=strlen(token->data)+1;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Null;
*node=cur;
end=token->next;
return end;
}
static Token *parseTrue(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
int len=0;
len=strlen(token->data)+1;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_True;
*node=cur;
end=token->next;
return end;
}
static Token *parseFalse(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
int len=0;
len=strlen(token->data)+1;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_False;
*node=cur;
end=token->next;
return end;
}
static Token *parseSelf(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Self;
*node=cur;
end=token->next;
return end;
}
static Token *parseSuper(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Super;
*node=cur;
end=token->next;
return end;
}
static Token *parseStringExpr(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
int len=0;
len=strlen(token->data)+1;
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_String;
cur->data=(char *)calloc(len, sizeof(char ));
strcpy(cur->data, token->data);
*node=cur;
end=token->next;
return end;
}
static Token *parsePrior(Token *token,ASTNode **node){
Token *end=NULL;
Token *bound=NULL;
ASTNode *parent=NULL;
ASTNode *child=NULL;
Token *error=token;
bound=__boundParenth(token);
if(!bound){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
if(bound){
parent=(ASTNode *)calloc(1, sizeof(ASTNode ));
parent->type=ASTType_Expr;
parent->op=ASTOp_Prior;
parent->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
parent->childLength=1;
end=parseExpr(token->next,bound,NULL,&child);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, token->next);
freeASTNode(parent);
freeASTNode(child);
return NULL;
}
if(end==bound){ // 存在
parent->childArr[0]=child;
child->parent=parent;
*node=parent;
end=end->next;
return end;
}
}
// error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(parent);
freeASTNode(child);
return NULL;
}
static Token *parseMono(Token *token,Token *terminal,ASTNode **node){
Token *end=NULL;
Token *bound=NULL;
ASTNode *monoNode=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
ASTNode *curNode=NULL;
Token *_token=NULL;
bound=__boundMonoExpr(token);
if(!bound){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
while(token&&bound){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Expr;
curNode->childLength=1;
curNode->childArr=(ASTNode **)calloc(1, sizeof( ASTNode *));
if(token->subType==TokenSubType_Not){ // !
curNode->op=ASTOp_Not;
}
else if(token->subType==TokenSubType_Reverse){ // ~
curNode->op=ASTOp_Reverse;
}
else if(token->subType==TokenSubType_New){ // New
curNode->op=ASTOp_New;
}
else{ // -
curNode->op=ASTOp_Negative;
}
if(monoNode){
monoNode->childArr[0]=curNode;
curNode->parent=monoNode;
}
monoNode=curNode;
if(token==bound){
break;
}
token=token->next;
}
token=__parseOpenExpr(bound->next,terminal,&leftNode);
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, bound->next);
freeASTNode(curNode);
freeASTNode(leftNode);
return NULL;
}
if(token==terminal){
monoNode->childArr[0]=leftNode;
leftNode->parent=monoNode;
*node=astNode_getRootNode(monoNode);
return terminal;
}
_token=token;
token=__parseReduceExpr(token,terminal,leftNode,&rightNode);
if(!token){
// error_throwError(ErrorType_ExprSyntaxError, _token);
freeASTNode(curNode);
freeASTNode(leftNode);
freeASTNode(rightNode);
return NULL;
}
monoNode->childArr[0]=rightNode;
rightNode->parent=monoNode;
*node=astNode_getRootNode(monoNode);
end=token;
return end;
}
static Token *parseNot(Token *token,Token *terminal,ASTNode **node){
Token *end=NULL;
end=parseMono(token,terminal,node);
return end;
}
static Token *parseNegative(Token *token,Token *terminal,ASTNode **node){
Token *end=NULL;
end=parseMono(token,terminal,node);
return end;
}
// new Indentity|(Expr) || new Expr ???
static Token *parseNew(Token *token,Token *terminal,ASTNode **node){
Token *end=NULL;
end=parseMono(token,terminal,node);
return end;
}
static Token *parseReverse(Token *token,Token *terminal,ASTNode **node){
Token *end=NULL;
end=parseMono(token,terminal,node);
return end;
}
// state 相关 ???
static Token *parseState(Token *token, ASTNode **node){
Token *end=NULL;
if(__isIfState(token)){
end=parseIfState(token,node);
}
else if(__isWhileState(token)){
end=parseWhileState(token,node);
}
else if(__isStaticState(token)){ // ??? function/field pre
end=parseStaticState(token,node);
}
else if(__isForState(token)){
end=parseForState(token,node);
}
else if(__isFunctionState(token)){
end=parseFunctionState(token,node);
}
else if(__isClassState(token)){
end=parseClassState(token,node);
}
else if(__isContinueState(token)){
end=parseContinueState(token,node);
}
else if(__isBreakState(token)){
end=parseBreakState(token,node);
}
else if(__isReturnState(token)){
end=parseReturnState(token,node);
}
else if(__isUpState(token)){
end=parseUpState(token,node);
}
else if(__isGlobalState(token)){
end=parseGlobalState(token,node);
}
else if(__isFieldState(token)){
end=parseFieldState(token,node);
}
else if(__isYieldState(token)){
end=parseYieldState(token,node);
}
else if(__isImportState(token)){
end=parseImportState(token,node);
}
else if(__isPrintState(token)){
end=parsePrintState(token,node);
}
else if(__isAssignState(token)){ // ??? block next
end=parseAssignState(token, node);
}
else{ // ??? __isExprState
end=parseExprState(token, node);
}
return end;
}
/***
block check ???
****/
static Token *parseBlock(Token *start,Token *end,ASTNode **node){
Token *token=NULL;
ASTNode *blockNode=NULL;
ASTNode *head=NULL;
ASTNode *cur=NULL;
blockNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
blockNode->type=ASTType_Block;
token=start->next;
if(token==end){
*node=blockNode;
end=end->next;
return end;
}
token=filterEmpty(token);
if(token==end){
*node=blockNode;
end=end->next;
return end;
}
token=parseState(token,&head);
if(token){
blockNode->childLength=1;
blockNode->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
blockNode->childArr[0]=head;
head->parent=blockNode;
cur=head;
if(token==end){
*node=blockNode;
end=end->next;
return end;
}
token=filterEmpty(token);
while(token!=end){
ASTNode *_cur=NULL;
token=parseState(token,&_cur);
if(!_cur){ // block失败
freeASTNode(blockNode);
freeASTNode(_cur);
break;
}
cur->next=_cur;
_cur->parent=blockNode;
cur=cur->next;
token=filterEmpty(token);
}
*node=blockNode;
end=end->next;
return end;
}
freeASTNode(blockNode);
return NULL;
}
static Token *parseExprState(Token *token,ASTNode **node){
Token *end=NULL;
Token *tail=NULL;
Token *error=token;
end=__boundExprState(token);
if(!end){
error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
if(end){
tail=parseExpr(token, end, NULL, node);
if(!tail){
error_throwError(ErrorType_ExprSyntaxError, token);
freeASTNode(*node);
*node=NULL;
return NULL;
}
if(tail==end){
end=end->next;
return end;
}
}
error_throwError(ErrorType_ExprSyntaxError, error);
freeASTNode(*node);
*node=NULL;
return NULL;
}
static Token *parseAssignState(Token *token,ASTNode **node){
Token *end=NULL;
Token *aToken=NULL;
ASTNode *curNode=NULL;
ASTNode *leftNode=NULL;
ASTNode *rightNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundAssignState(token);
if(!end){
error_throwError(ErrorType_AssignSyntaxError, token);
return NULL;
}
if(end){
aToken=__boundAssign(token, end);
if(!aToken){
error_throwError(ErrorType_AssignSyntaxError, token);
return NULL;
}
if(aToken){
_token=token;
// token=parseExpr(token, aToken, NULL, &leftNode);
token=__parseComma(token, aToken, 1, &leftNode);
if(!token){
error_throwError(ErrorType_AssignSyntaxError, _token);
freeASTNode(leftNode);
return NULL;
}
if(token==aToken){
_token=token->next;
// token=parseExpr(token->next, end, NULL, &rightNode);
token=__parseComma(token->next, end, 0, &rightNode);
if(!token){
error_throwError(ErrorType_AssignSyntaxError, _token);
freeASTNode(leftNode);
freeASTNode(rightNode);
return NULL;
}
if(token==end){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Assign;
curNode->childLength=2;
curNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
curNode->childArr[0]=leftNode;
leftNode->parent=curNode;
curNode->childArr[1]=rightNode;
rightNode->parent=curNode;
if(aToken->subType==TokenSubType_Assign){
curNode->op=ASTOp_DeclareAssign;
}
else if(aToken->subType==TokenSubType_MulAssgin){
curNode->op=ASTOp_MulAssgin;
}
else if(aToken->subType==TokenSubType_DivAssgin){
curNode->op=ASTOp_DivAssgin;
}
else if(aToken->subType==TokenSubType_ModAssgin){
curNode->op=ASTOp_ModAssgin;
}
else if(aToken->subType==TokenSubType_AddAssgin){
curNode->op=ASTOp_AddAssgin;
}
else if(aToken->subType==TokenSubType_SubAssgin){
curNode->op=ASTOp_SubAssgin;
}
else if(aToken->subType==TokenSubType_LeftShiftAssgin){
curNode->op=ASTOp_LeftShiftAssgin;
}
else if(aToken->subType==TokenSubType_RightShiftAssgin){
curNode->op=ASTOp_RightShiftAssgin;
}
else if(aToken->subType==TokenSubType_XOrAssgin){
curNode->op=ASTOp_XOrAssgin;
}
else if(aToken->subType==TokenSubType_XAndAssgin){
curNode->op=ASTOp_XAndAssgin;
}
else if(aToken->subType==TokenSubType_XErAssgin){
curNode->op=ASTOp_XErAssgin;
}
else{
error_throwError(ErrorType_AssignSyntaxError, aToken);
freeASTNode(curNode);
return NULL;
}
*node=curNode;
end=end->next;
return end;
}
}
}
}
error_throwError(ErrorType_AssignSyntaxError, error);
return NULL;
}
/***
If={IfTerm,EleseIfTerm,EleseBlock}
Ifterm={Expr,IfBlock}
EleseIfTerm={Expr,EleseIfBlock}
****/
static Token *parseIfState(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *ifNode=NULL;
ASTNode *termNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
int termLen=0;
int blockLen=0;
int len=0;
end=__boundIfState(token);
if(!end){
error_throwError(ErrorType_IfSyntaxError, token);
return NULL;
}
termLen=__calIfConditionLength(token,end);
blockLen=__calIfBlockLength(token,end);
ifNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
ifNode->type=ASTType_If;
ifNode->childLength=blockLen;
ifNode->childArr=(ASTNode **)calloc(blockLen, sizeof(ASTNode *));
// if
start=token->next;
if(start->subType==TokenSubType_LeftParenth){ // (
end=__boundParenth(start);
if(!end){
error_throwError(ErrorType_IfSyntaxError, start);
return NULL;
}
_token=start->next;
start=parseExpr(start->next, end, NULL, &exprNode);
if(!start){
error_throwError(ErrorType_IfSyntaxError, _token);
freeASTNode(exprNode);
return NULL;
}
start=start->next;
if(start->subType==TokenSubType_LeftBrace){ // {
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_IfSyntaxError, start);
freeASTNode(exprNode);
return NULL;
}
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
if(end){ // term
termNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
termNode->type=ASTType_Expr;
termNode->op=ASTOp_IfTerm;
termNode->childLength=2;
termNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
termNode->childArr[0]=exprNode;
exprNode->parent=termNode;
termNode->childArr[1]=blockNode;
blockNode->parent=termNode;
blockNode->op=ASTOp_IfBlock;
ifNode->childArr[0]=termNode;
termNode->parent=ifNode;
len++;
start=end;
*node=ifNode;
}
}
}
while(start){ // else if/else
if(start->subType==TokenSubType_Else){
start=start->next;
if(start->subType==TokenSubType_LeftBrace){ // else {
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_IfSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
if(end){ // block
ifNode->childArr[len]=blockNode;
blockNode->parent=ifNode;
blockNode->op=ASTOp_ElseBlock;
len++;
start=end;
*node=ifNode;
}
}
else if(start->subType==TokenSubType_If){ // else if
start=start->next;
if(start->subType==TokenSubType_LeftParenth){
end=__boundParenth(start);
if(!end){
error_throwError(ErrorType_IfSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
_token=start->next;
start=parseExpr(start->next, end, NULL, &exprNode);
if(!start){
error_throwError(ErrorType_IfSyntaxError, _token);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
start=start->next;
if(start->subType==TokenSubType_LeftBrace){ // {
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_IfSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
return NULL;
}
if(end){ // term
termNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
termNode->type=ASTType_Expr;
termNode->op=ASTOp_ElseIfTerm;
termNode->childLength=2;
termNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
termNode->childArr[0]=exprNode;
exprNode->parent=termNode;
termNode->childArr[1]=blockNode;
blockNode->parent=termNode;
blockNode->op=ASTOp_ElseIfTerm;
ifNode->childArr[len]=termNode;
termNode->parent=ifNode;
len++;
start=end;
*node=ifNode;
}
}
}
}
else{ // error
error_throwError(ErrorType_IfSyntaxError, start);
freeASTNode(exprNode);
freeASTNode(blockNode);
freeASTNode(ifNode);
return NULL;
}
}
else{
break;
}
}
if(!end||len!=blockLen){
error_throwError(ErrorType_IfSyntaxError, error);
freeASTNode(exprNode);
freeASTNode(blockNode);
freeASTNode(ifNode);
return NULL;
}
return end;
}
/***
While={WhileTerm,WhileBlock}
WhileTerm={Expr}
****/
static Token *parseWhileState(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *whileNode=NULL;
ASTNode *termNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
start=token->next;
if(start->subType==TokenSubType_LeftParenth){
end=__boundParenth(start);
if(!end){
error_throwError(ErrorType_WhileSyntaxError, start);
return NULL;
}
if(end){
termNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
termNode->type=ASTType_Expr;
termNode->op=ASTOp_WhileTerm;
termNode->childLength=1;
termNode->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
end=parseExpr(start->next, end, NULL, &exprNode);
if(!end){
error_throwError(ErrorType_WhileSyntaxError, start->next);
return NULL;
}
if(end){
termNode->childArr[0]=exprNode;
exprNode->parent=termNode;
start=end->next;
if(start->subType==TokenSubType_LeftBrace){
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_WhileSyntaxError, start);
return NULL;
}
if(end){
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
return NULL;
}
if(end){
whileNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
whileNode->type=ASTType_While;
whileNode->childLength=2;
whileNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
whileNode->childArr[0]=termNode;
termNode->parent=whileNode;
whileNode->childArr[1]=blockNode;
blockNode->op=ASTOp_WhileBlock;
blockNode->parent=whileNode;
*node=whileNode;
return end;
}
}
}
}
}
}
error_throwError(ErrorType_WhileSyntaxError, error);
return NULL;
}
/***
For={ForTerm,ForBlock}
ForTerm={Expr,Expr}
ForTerm={Assign,Expr,Assign}
****/
static Token *parseForState(Token *token,ASTNode **node){
Token *end=NULL;
Token *inToken=NULL;
end=__boundParenth(token);
if(!end){
error_throwError(ErrorType_ForSyntaxError, token);
return NULL;
}
inToken=__boundIn(token->next->next, end);
if(inToken){
end=__parseForInState(token,inToken,node);
}
else{
end=__parseForThreeState(token, node);
}
return end;
}
static Token *__parseForInState(Token *token,Token *inToken,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *forNode=NULL;
ASTNode *termNode=NULL;
ASTNode *exprNode1=NULL;
ASTNode *exprNode2=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
start=token->next;
if(start->subType==TokenSubType_LeftParenth){ // (
end=__boundParenth(start);
if(!end){
error_throwError(ErrorType_ForSyntaxError, start);
return NULL;
}
if(end){
termNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
termNode->type=ASTType_Expr;
termNode->op=ASTOp_ForTerm;
termNode->childLength=2;
termNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
token=start->next;
start=inToken;
_token=token;
// token=parseExpr(token, start, NULL, &exprNode1);
token=__parseComma(token, start, 2, &exprNode1);
if(!token){
error_throwError(ErrorType_ForSyntaxError, _token);
return NULL;
}
if(token){
// end=parseExpr(start->next, end, NULL, &exprNode2);
end=__parseComma(start->next, end, 0, &exprNode2);
if(!end){
error_throwError(ErrorType_ForSyntaxError, start->next);
return NULL;
}
if(exprNode1->childLength!=exprNode2->childLength){
error_throwError(ErrorType_ForSyntaxError, start->next);
return NULL;
}
if(end){
termNode->childArr[0]=exprNode1;
exprNode1->parent=termNode;
termNode->childArr[1]=exprNode2;
exprNode2->parent=termNode;
start=end->next;
if(start->subType==TokenSubType_LeftBrace){ // {
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_ForSyntaxError, start);
return NULL;
}
if(end){
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
return NULL;
}
if(end){
forNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
forNode->type=ASTType_For;
forNode->childLength=2;
forNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
forNode->childArr[0]=termNode;
termNode->parent=forNode;
forNode->childArr[1]=blockNode;
blockNode->op=ASTOp_ForBlock;
blockNode->parent=forNode;
*node=forNode;
return end;
}
}
}
}
}
}
}
error_throwError(ErrorType_ForSyntaxError, error);
return NULL;
}
static Token *__parseForThreeState(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *forNode=NULL;
ASTNode *termNode=NULL;
ASTNode *exprNode1=NULL;
ASTNode *exprNode2=NULL;
ASTNode *exprNode3=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
start=token->next;
if(start->subType==TokenSubType_LeftParenth){ // (
end=__boundParenth(start);
if(!end){
error_throwError(ErrorType_ForSyntaxError, start);
return NULL;
}
if(end){
termNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
termNode->type=ASTType_Expr;
termNode->op=ASTOp_ForTerm;
termNode->childLength=3;
termNode->childArr=(ASTNode **)calloc(3, sizeof(ASTNode *));
token=start->next;
_token=token;
token=parseAssignState(token, &exprNode1);
token=filterEmpty(token);
if(!token){
error_throwError(ErrorType_ForSyntaxError, _token);
return NULL;
}
if(token){
_token=token;
token=parseExprState(token, &exprNode2);
token=filterEmpty(token);
if(!token){
error_throwError(ErrorType_ForSyntaxError, _token);
return NULL;
}
if(token){
Token *_token=NULL;
Token *_pre=NULL;
if(end->pre->subType!=TokenSubType_Semicolon){ // ;
_token=(Token *)calloc(1, sizeof(Token ));
_pre=end->pre;
_token->type=TokenType_Delimiter;
_token->subType=TokenSubType_Semicolon;
_token->row=_pre->row;
_token->column=_pre->column;
_pre->next=_token;
_token->pre=_pre;
_token->next=end;
end->pre=_pre;
}
end=parseAssignState(token,&exprNode3);
end=filterEmpty(end);
if(!end){
error_throwError(ErrorType_ForSyntaxError, token);
return NULL;
}
if(end){
termNode->childArr[0]=exprNode1;
exprNode1->parent=termNode;
termNode->childArr[1]=exprNode2;
exprNode2->parent=termNode;
termNode->childArr[2]=exprNode3;
exprNode3->parent=termNode;
start=end->next;
if(start->subType==TokenSubType_LeftBrace){ // {
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_ForSyntaxError, start);
return NULL;
}
if(end){
end=parseBlock(start,end,&blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
return NULL;
}
if(end){
forNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
forNode->type=ASTType_For;
forNode->childLength=2;
forNode->childArr=(ASTNode **)calloc(2, sizeof(ASTNode *));
forNode->childArr[0]=termNode;
termNode->parent=forNode;
forNode->childArr[1]=blockNode;
blockNode->op=ASTOp_ForBlock;
blockNode->parent=forNode;
*node=forNode;
return end;
}
}
}
}
}
}
}
}
error_throwError(ErrorType_ForSyntaxError, error);
return NULL;
}
static Token *parseFunctionState(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *functionNode=NULL;
ASTNode *nameNode=NULL;
ASTNode *argNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundFunctionState(token);
if(!end){
error_throwError(ErrorType_FunctionSyntaxError, token);
return NULL;
}
start=token->next;
functionNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
functionNode->type=ASTType_Function;
functionNode->childLength=3;
functionNode->childArr=(ASTNode **)calloc(3, sizeof(ASTNode *));
if(start->type==TokenType_Identify){ // name
_token=start;
start=parseExpr(start, start->next, NULL, &nameNode);
if(!start){
error_throwError(ErrorType_FunctionSyntaxError, _token);
return NULL;
}
if(nameNode->op!=ASTOp_Indentify){
error_throwError(ErrorType_FunctionSyntaxError, _token);
return NULL;
}
if(start->subType==TokenSubType_LeftParenth){ // arg
_token=start;
start=parseArguments(start, &argNode);
if(!start){
error_throwError(ErrorType_FunctionSyntaxError, _token);
return NULL;
}
if(start->subType==TokenSubType_LeftBrace){ // state
end=parseBlock(start, end, &blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
return NULL;
}
if(end){
functionNode->childArr[0]=nameNode;
nameNode->parent=functionNode;
functionNode->childArr[1]=argNode;
argNode->parent=functionNode;
functionNode->childArr[2]=blockNode;
blockNode->op=ASTOp_FunctionBlock;
blockNode->parent=functionNode;
*node=functionNode;
return end;
}
}
}
}
error_throwError(ErrorType_FunctionSyntaxError, error);
return NULL;
}
// Class={Name,Expr,ClassBlock}
static Token *parseClassState(Token *token,ASTNode **node){
Token *end=NULL;
Token *start=NULL;
ASTNode *classNode=NULL;
ASTNode *nameNode=NULL;
ASTNode *exprNode=NULL;
ASTNode *blockNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundClassState(token);
if(!end){
error_throwError(ErrorType_ClassSyntaxError, token);
return NULL;
}
start=token->next;
classNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
classNode->type=ASTType_Class;
classNode->childLength=3;
classNode->childArr=(ASTNode **)calloc(3, sizeof(ASTNode *));
if(start->type==TokenType_Identify){ // name
_token=start;
start=parseExpr(start, start->next, NULL, &nameNode);
if(!start){
error_throwError(ErrorType_ClassSyntaxError, _token);
return NULL;
}
if(nameNode->op!=ASTOp_Indentify){
error_throwError(ErrorType_ClassSyntaxError, _token);
return NULL;
}
if(start->subType==TokenSubType_LeftParenth||
start->subType==TokenSubType_LeftBrace){ // (||{
if(start->subType==TokenSubType_LeftParenth){
Token *_end=NULL;
_end=__boundParenth(start);
if(!_end){
error_throwError(ErrorType_ClassSyntaxError, start);
return NULL;
}
if(start->next!=_end){
_token=start->next;
start=parseExpr(start->next, _end,NULL,&exprNode);
if(!start){
error_throwError(ErrorType_ClassSyntaxError, _token);
return NULL;
}
}
else{
start=start->next;
}
start=start->next;
}
if(start->subType==TokenSubType_LeftBrace){ // block
end=__boundBrace(start);
if(!end){
error_throwError(ErrorType_ClassSyntaxError, start);
return NULL;
}
end=parseBlock(start, end, &blockNode);
if(!end){
// error_throwError(ErrorType_ExprSyntaxError, start);
return NULL;
}
if(end){
classNode->childArr[0]=nameNode;
nameNode->parent=classNode;
if(exprNode){
classNode->childArr[1]=exprNode;
exprNode->parent=classNode;
}
classNode->childArr[2]=blockNode;
blockNode->op=ASTOp_ClassBlock;
blockNode->parent=classNode;
*node=classNode;
return end;
}
}
}
}
error_throwError(ErrorType_ClassSyntaxError, error);
return NULL;
}
static Token *parseContinueState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
Token *error=token;
end=__boundContinueState(token);
if(!end){
error_throwError(ErrorType_ContinueSyntaxError, token);
return NULL;
}
if(end==token->next){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Continue;
*node=curNode;
end=end->next;
return end;
}
error_throwError(ErrorType_ContinueSyntaxError, error);
return NULL;
}
static Token *parseBreakState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
Token *error=token;
end=__boundContinueState(token);
if(!end){
error_throwError(ErrorType_BreakSyntaxError, token);
return NULL;
}
if(end==token->next){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Break;
*node=curNode;
end=end->next;
return end;
}
error_throwError(ErrorType_BreakSyntaxError, error);
return NULL;
}
static Token *parseReturnState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
ASTNode *exprNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundReturnState(token);
if(!end){
error_throwError(ErrorType_ReturnSyntaxError, token);
return NULL;
}
if(end){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Return;
curNode->childLength=1;
curNode->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
if(token->next==end){ // return ;
exprNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
exprNode->type=ASTType_Expr;
exprNode->op=ASTOp_Null;
curNode->childArr[0]=exprNode;
exprNode->parent=curNode;
*node=curNode;
end=end->next;
return end;
}
else{
_token=token->next;
token=parseExpr(token->next, end, NULL, &exprNode);
if(!token){
error_throwError(ErrorType_ReturnSyntaxError, _token);
return NULL;
}
if(token==end){
curNode->childArr[0]=exprNode;
exprNode->parent=curNode;
*node=curNode;
end=end->next;
return end;
}
}
}
error_throwError(ErrorType_ReturnSyntaxError, error);
return NULL;
}
static Token *parseYieldState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *curNode=NULL;
ASTNode *exprNode=NULL;
Token *error=token;
Token *_token=NULL;
end=__boundYieldState(token);
if(!end){
error_throwError(ErrorType_YieldSyntaxError, token);
return NULL;
}
if(end){
curNode=(ASTNode *)calloc(1, sizeof(ASTNode ));
curNode->type=ASTType_Yield;
curNode->childLength=1;
curNode->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
_token=token->next;
token=parseExpr(token->next, end, NULL, &exprNode);
if(!token){
error_throwError(ErrorType_YieldSyntaxError, _token);
return NULL;
}
if(token==end){
curNode->childArr[0]=exprNode;
exprNode->parent=curNode;
*node=curNode;
end=end->next;
return end;
}
}
error_throwError(ErrorType_YieldSyntaxError, error);
return NULL;
}
static Token *__parseArguments(Token *token,int flag,ASTNode **node){
Token *end=NULL;
Token *tail=NULL;
Token *split=NULL;
ASTNode *cur=NULL;
ASTNode *elemet=NULL;
ASTNode **nodeArr=NULL;
int length=0;
int len=0;
Token *_token=NULL;
end=__boundParenth(token);
if(!end){
return NULL;
}
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Arguments;
length=__calArgumentsLength(token,end);
if(length){
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
token=token->next;
tail=end;
while(token!=end){
_token=token;
split=__boundComma(token,end);
if(split){
if(token->subType==TokenSubType_Out){
tail=parseExpr(token->next,split,NULL,&elemet);
if(tail){
if(elemet->op!=ASTOp_Indentify){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
elemet->value.outFlag=1;
}
else {
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
}
else{
tail=parseExpr(token,split,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
}
token=split->next;
}
else{
if(token->subType==TokenSubType_Out){
tail=parseExpr(token->next,end,NULL,&elemet);
if(tail){
if(elemet->op!=ASTOp_Indentify){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
elemet->value.outFlag=1;
}
else{
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
}
else{
tail=parseExpr(token,end,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
}
token=end;
}
if(flag){ // state
if(elemet->op==ASTOp_Indentify){
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
else{
return NULL;
}
}
else{
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
}
}
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
return end->next;
}
// length 1 expr >1 comma
static Token *__parseComma(Token *token,Token *tail,int flag,ASTNode **node){
Token *end=NULL;
Token *split=NULL;
ASTNode *cur=NULL;
ASTNode *elemet=NULL;
ASTNode **nodeArr=NULL;
int length=0;
int len=0;
int _flag=0;
Token *_token=NULL;
length=__calCommaCount(token,tail,1);
if(length==1){
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Comma;
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
end=parseExpr(token,tail,NULL,&elemet);
if(end){
if(flag){
if(flag==1){
if(elemet->op==ASTOp_Indentify||
elemet->op==ASTOp_Property||
elemet->op==ASTOp_Subscript){
_flag=1;
}
}
else{
if(elemet->op==ASTOp_Indentify){
_flag=1;
}
}
}
else{
_flag=1;
}
}
if(_flag){
nodeArr[0]=elemet;
elemet->parent=cur;
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
return end;
}
else{
return NULL;
}
}
else if(length>1){
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=ASTType_Expr;
cur->op=ASTOp_Comma;
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
end=tail;
while(token!=end){
_token=token;
split=__boundComma(token,end);
if(split){
tail=parseExpr(token,split,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
token=split->next;
}
else{
tail=parseExpr(token,end,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
token=end;
}
if(flag){ // state
if(flag==1){
if(elemet->op==ASTOp_Indentify||
elemet->op==ASTOp_Property||
elemet->op==ASTOp_Subscript){
_flag=1;
}
}
else {
if(elemet->op==ASTOp_Indentify){
_flag=1;
}
}
}
else{
_flag=1;
}
if(_flag){
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
else{
return NULL;
}
}
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
return end;
}
return NULL;
}
static Token *parseArguments(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseArguments(token,1,node);
if(!end){
// error_throwError(ErrorType_FunctionSyntaxError, token);
}
return end;
}
static int __isImportHander(ASTNode *node){
int flag=0;
if(node){
if(node->op==ASTOp_Property||
node->op==ASTOp_Indentify){
flag=1;
}
}
return flag;
}
static Token *parseImportState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
ASTNode *exprNode=NULL;
int flag=0;
Token *error=token;
end=__boundImportState(token);
if(!end){
error_throwError(ErrorType_ImportSyntaxError, token);
return NULL;
}
end=parseExpr(token->next, end, NULL, &exprNode);
if(!end){
error_throwError(ErrorType_ImportSyntaxError, token->next);
freeASTNode(exprNode);
return NULL;
}
if(end){
flag=astNode_all(exprNode, __isImportHander);
if(flag){
cur=(ASTNode *)calloc(1, sizeof(ASTNode *));
cur->type=ASTType_Import;
cur->childLength=1;
cur->childArr=(ASTNode **)calloc(1, sizeof(ASTNode ));
cur->childArr[0]=exprNode;
exprNode->parent=cur;
*node=cur;
end=end->next;
return end;
}
}
error_throwError(ErrorType_ImportSyntaxError, error);
freeASTNode(exprNode);
return NULL;
}
static Token *__parseSemState(Token *token,ASTNode **node,ASTType type,int flag){
Token *end=NULL;
Token *tail=NULL;
Token *split=NULL;
ASTNode *cur=NULL;
ASTNode *elemet=NULL;
ASTNode **nodeArr=NULL;
int length=0;
int len=0;
end=__boundSemicolon(token);
if(!end){
return NULL;
}
length=__calArgumentsLength(token,end);
if(length){
cur=(ASTNode *)calloc(1, sizeof(ASTNode ));
cur->type=type;
nodeArr=(ASTNode **)calloc(length, sizeof(ASTNode *));
token=token->next;
tail=end;
while(token!=end){
split=__boundComma(token,end);
if(split){
tail=parseExpr(token,split,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
token=split->next;
}
else{
tail=parseExpr(token,end,NULL,&elemet);
if(!tail){
// error_throwError(ErrorType_ExprSyntaxError, token);
return NULL;
}
token=end;
}
if(flag){
if(elemet->op==ASTOp_Indentify){
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
else{
return NULL;
}
}
else{
nodeArr[len]=elemet;
elemet->parent=cur;
len++;
}
}
cur->childLength=length;
cur->childArr=(ASTNode **)nodeArr;
*node=cur;
end=end->next;
return end;
}
return NULL;
}
static Token *parseUpState(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseSemState(token, node, ASTType_Up, 1);
if(!end){
error_throwError(ErrorType_UpSyntaxError, token);
}
return end;
}
static Token *parseGlobalState(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseSemState(token, node, ASTType_Global, 1);
if(!end){
error_throwError(ErrorType_GlobalSyntaxError, token);
}
return end;
}
static Token *parseFieldState(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseSemState(token, node, ASTType_Field, 1);
if(!end){
error_throwError(ErrorType_FieldSyntaxError, token);
}
return end;
}
static Token *parseStaticState(Token *token,ASTNode **node){
Token *end=NULL;
ASTNode *cur=NULL;
ASTNode *element=NULL;
Token *error=token;
if(token->next){
token=token->next;
if(token->subType==TokenSubType_Field){
end=parseFieldState(token, &element);
}
else if(token->subType==TokenSubType_Def){
end=parseFunctionState(token, &element);
}
else{
error_throwError(ErrorType_StaticSyntaxError, error);
}
if(end){
cur=(ASTNode *)calloc(1,sizeof(ASTNode ));
cur->type=ASTType_Static;
cur->childLength=1;
cur->childArr=(ASTNode **)calloc(1, sizeof(ASTNode *));
cur->childArr[0]=element;
element->parent=cur;
*node=cur;
}
}
else{
error_throwError(ErrorType_StaticSyntaxError, error);
}
return end;
}
static Token *parsePrintState(Token *token,ASTNode **node){
Token *end=NULL;
end=__parseSemState(token, node, ASTType_Print, 0);
if(!end){
error_throwError(ErrorType_PrintSyntaxError, token);
}
return end;
}
void freeASTNode(ASTNode *node){
if(node){
free(node->data);
wrap_release(node->wrap);
for(int i=0;i<node->childLength;i++){
freeASTNode(node->childArr[i]);
}
free(node->childArr);
freeASTNode(node->next);
free(node);
}
}
|
liufeigit/Van-lang
|
src/van_vm.c
|
// clang
#include "van_vm.h"
|
liufeigit/Van-lang
|
src/van_data.h
|
#ifndef VAN_DATA_H
#define VAN_DATA_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "van_enum.h"
typedef enum {
FieldDesc_IsNull=0, // read
FieldDesc_IsRead=1, // hidden
FieldDesc_IsWrite=2, // overwrite
FieldDesc_IsGet=4, // readProperty
FieldDesc_IsSet=8, // writeProperty
FieldDesc_IsCall=16, // ins/class call
FieldDesc_IsNew=32, // static class
FieldDesc_IsBind=64, // static function
} FieldDesc;
typedef enum {
FunctionType_Normal=0,
FunctionType_NativeFunction=1,
} FunctionType;
typedef enum {
ClassType_Normal=0,
ClassType_NativeClass=1,
} ClassType;
struct VanClass;
typedef struct VanWrap{
DataType type;
union {
signed char c1;
unsigned char c2;
short s1;
unsigned short s2;
int i1;
unsigned int i2;
float f;
long long l;
double d;
int isSuper;
FieldDesc fieldDesc;
} value;
FieldDesc _fieldDesc;
int _referNum;
void *data;
} VanWrap;
typedef struct Node{
VanWrap *data;
void *userData;
struct Node *next;
struct Node *pre;
} Node;
typedef struct VanString{
struct VanClass *cls;
int length;
int capacity;
char *data;
} VanString;
typedef struct VanList{
struct VanClass *cls;
int length;
int capacity;
Node *head;
Node *tail;
} VanList;
typedef struct VanMap{
struct VanClass *cls;
int length;
int capacity;
// char **keyArr;
Node *head;
Node *tail;
} VanMap;
typedef VanWrap *(*WrapMethod)(VanWrap *self,VanList *list);
typedef struct VanFunction{
struct VanClass *cls;
FunctionType type;
char *name;
VanMap *dict;
VanWrap *bindObj;
struct VanFunction *parent; // call
VanList *argList; // call
void *code; // block ASTNode ??? WrapMethod
char **argNameArr;
int argArrLength;
int *outFlagArr;
VanMap *globalScopeDict;
VanMap *upScopeDict;
VanMap *inScopeDict;
VanList *chainScopeList; // def
} VanFunction;
typedef struct VanClass{
struct VanClass *cls;
ClassType type;
char *name;
struct VanClass *base; // class
VanMap *clsDescDict;
VanMap *insDescDict;
VanMap *dict;
} VanClass;
typedef struct VanInstance{
VanClass *cls;
VanMap *dict;
} VanInstance;
// shared VanFunction
typedef struct VanNativeFunction{
char *name;
VanMap *dict;
VanWrap *bindObj;
struct VanFunction *parent; // call
// void *code; // WrapMethod
WrapMethod method;
char **argNameArr;
int argArrLength;
int *outFlagArr;
} VanNativeFunction;
typedef struct VanNativeClass{
char *name;
VanNativeFunction *functionArr;
} VanNativeClass;
typedef struct NativeData{
char *name;
} VanNativeData;
// null/true/false/byte/int/float/native/void
/***
wrap_retain
wrap_release
wrap_toString
****/
VanWrap *wrap_wrapNull();
VanWrap *wrap_wrapTrue();
VanWrap *wrap_wrapFalse();
VanWrap *wrap_wrapByte(signed char c);
VanWrap *wrap_wrapUByte(unsigned char c);
VanWrap *wrap_wrapShort(short c);
VanWrap *wrap_wrapUShort(unsigned short c);
VanWrap *wrap_wrapInt(int l);
VanWrap *wrap_wrapUInt(unsigned int l);
VanWrap *wrap_wrapLong(long l);
VanWrap *wrap_wrapLongLong(long long l);
VanWrap *wrap_wrapFloat(float d);
VanWrap *wrap_wrapDouble(double d);
VanWrap *wrap_wrapString(VanString *str);
VanWrap *wrap_wrapList(VanList *list);
VanWrap *wrap_wrapMap(VanMap *map);
VanWrap *wrap_wrapFunction(VanFunction *func);
VanWrap *wrap_wrapClass(VanClass *cls);
VanWrap *wrap_wrapInstance(VanInstance *ins);
VanWrap *wrap_wrapNativeFunction(VanNativeFunction *func);
VanWrap *wrap_wrapOpaquePointer(void *data);
VanWrap *wrap_wrapRefData(VanWrap **data);
void wrap_retain(VanWrap *wrap);
void wrap_release(VanWrap *wrap);
char *wrap_toString(VanWrap * wrap);
// string
/***
string_length
string_getValue
string_setValue
string_add
string_mul
string_subString
string_replace
string_find
string_split
string_reverse
string_convertNumber
string_slice
string_equal
string_toString
****/
VanString *string_create(char *data);
int string_length(VanString *str);
char *string_add(VanString *str1,char *data);
VanList *string_split(VanString *str1,char *data);
int string_setValue(VanString *str,char c);
char *string_getValue(VanString *str);
char *string_subString(VanString *str,int start,int end);
char *string_toString(VanString *str);
void string_free(VanString *str);
// list
/***
list_push
list_pop
list_setValue
list_getValue
list_add
list_remove
list_sort
list_filter
list_map
list_equal
list_forEach
list_reverse
list_slice
list_indexOf
list_lastIndexOf
list_toString
****/
VanList *list_create(int length);
int list_length(VanList *list);
VanList *list_push(VanList *list,VanWrap *value);
VanWrap *list_pop(VanList *list);
int list_indexOf(VanList *list,VanWrap *value);
int list_lastIndexOf(VanList *list,VanWrap *value);
void list_setValue(VanList *list,int index,VanWrap *value);
VanWrap *list_getValue(VanList *list,int index);
char *list_toString(VanList *list);
void list_free(VanList *list);
// map
/***
map_setValue
map_getValue
map_keyArr
map_valueArr
****/
VanMap *map_create();
int map_length(VanMap *map);
void map_setValue(VanMap *map,char *key,VanWrap *value);
void map_setRefValue(VanMap *map,char *key,VanWrap *value);
VanWrap *map_getValue(VanMap *map,char *key);
VanWrap *map_getRefValue(VanMap *map,char *key);
int map_hasKey(VanMap *map,char *key);
char **map_keyArr(VanMap *map);
VanList *map_valueArr(VanMap *map);
char *map_toString(VanMap *map);
void map_free(VanMap *map);
// function
/***
function_bind
function_unBind
function_setValue
function_getValue
function_setInScopeValue
function_getInScopeValue
function_setUpScopeValue
function_getUpScopeValue
****/
VanFunction *function_create(char *name,char **argNameArr,int *outFlagArr,int length);
void function_bind(VanFunction *func,VanWrap *obj);
VanWrap *function_unBind(VanFunction *func);
void function_setValue(VanFunction *func,char *key,VanWrap *value);
VanWrap *function_getValue(VanFunction *func,char *key);
void function_setInScopeValue(VanFunction *func,char *name,VanWrap *value);
VanWrap *function_getInScopeValue(VanFunction *func,char *name);
void function_setUpScopeValue(VanFunction *func,char *name,VanWrap *value);
VanWrap *function_getUpScopeValue(VanFunction *func,char *name);
char *function_toString(VanFunction *func);
void function_free(VanFunction *func);
// class
/***
class_addClsField
class_addInsField
class_setValue
class_getValue
class_base
****/
VanClass *class_create(char *name,VanClass *base);
void class_addClsField(VanClass *cls,char *name,VanWrap *value);
void class_addInsField(VanClass *cls,char *name,VanWrap *value);
void class_addClsWrapMethod(VanClass *cls,char *name,FieldDesc desc,int *outFlag,WrapMethod method);
void class_addInsWrapMethod(VanClass *cls,char *name,FieldDesc desc,int *outFlag,WrapMethod method);
void class_setValue(VanClass *cls,char *key,VanWrap *value);
VanWrap *class_getValue(VanClass *cls,char *key,int isSuper);
VanClass *class_base(VanClass *cls);
char *class_toString(VanClass *cls);
void class_free(VanClass *cls);
// instance
/***
instance_setValue
instance_getValue
instance_class
****/
VanWrap *instance_create(VanClass *cls,VanList *argList);
void instance_setValue(VanInstance *ins,char *key,VanWrap *value);
VanWrap *instance_getValue(VanInstance *ins,char *key,int isSuper);
VanClass *instance_class(VanInstance *ins);
char *instance_toString(VanInstance *ins);
void instance_free(VanInstance *ins);
// util
VanWrap *wrap_binaryCal(VanWrap *leftWrap,VanWrap *rightWrap,ASTOp op);
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_data.c
|
<filename>src/van_data.c
// clang
#include "van_data.h"
#include <stdlib.h>
static Node *node_getNodeFromIndex(Node *head,int index,int length);
static Node *node_getNodeFormKey(Node *head,char *key,int length,int *flag);
void __map_setValue(VanMap *map,char *key,VanWrap *value,int outFlag);
// string
VanString *string_create(char *data){
VanString *str=NULL;
int length=0;
str=(VanString *)calloc(1, sizeof(VanString ));
length=strlen(data);
str->length=length;
str->capacity=length;
str->data=data;
return str;
}
int string_length(VanString *str){
int length=0;
if(str){
length=str->length;
}
return length;
}
char *string_add(VanString *str1,char *data){
return NULL;
}
VanList *string_split(VanString *str1,char *data){
return NULL;
}
int string_setValue(VanString *str,char c){
return 0;
}
char *string_getValue(VanString *str){
return NULL;
}
char *string_subString(VanString *str,int start,int end){
return NULL;
}
char *string_toString(VanString *str){
char *str1=NULL;
int len1=0;
if(str){
if(str->data){
len1=strlen(str->data);
str1=(char *)calloc(len1+5, sizeof(char ));
strcpy(str1, str->data);
// str1[0]='\"';
// strcpy(str1+1, str->data);
// str1[len1+1]='\"';
}
}
return str1;
}
void string_free(VanString *str){
if(str){
free(str->data);
free(str);
}
}
// list
VanList *list_create(int length){
VanList *list=NULL;
Node *head=NULL;
Node *tail=NULL;
Node *preNode=NULL;
Node *curNode=NULL;
list=(VanList *)calloc(1, sizeof(VanList ));
head=(Node *)calloc(1, sizeof(Node ));
tail=(Node *)calloc(1, sizeof(Node ));
head->next=tail;
tail->pre=head;
list->length=length;
list->capacity=length;
preNode=head;
if(length){
for(int i=0;i<length;i++){
curNode=(Node *)calloc(1, sizeof(Node ));
curNode->data=wrap_wrapNull();
preNode->next=curNode;
curNode->pre=preNode;
preNode=curNode;
}
preNode->next=tail;
tail->pre=preNode;
}
list->head=head;
list->tail=tail;
return list;
}
int list_length(VanList *list){
int length=0;
if(list){
length=list->length;
}
return length;
}
VanList *list_push(VanList *list,VanWrap *value){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *cur=NULL;
Node *last=NULL;
length=list->length;
head=list->head;
tail=list->tail;
cur=(Node *)calloc(1, sizeof(Node ));
wrap_retain(value);
cur->data=value;
if(length){
last=tail->pre;
last->next=cur;
cur->pre=last;
cur->next=tail;
tail->pre=cur;
}
else{
head->next=cur;
cur->pre=head;
cur->next=tail;
tail->pre=cur;
}
length++;
list->length=length;
return list;
}
VanWrap *list_pop(VanList *list){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *last=NULL;
Node *lastPre=NULL;
VanWrap *value=NULL;
length=list->length;
head=list->head;
tail=list->tail;
if(length){
last=tail->pre;
lastPre=last->pre;
lastPre->next=tail;
tail->pre=lastPre;
// last->next=NULL;
// last->pre=NULL;
length--;
}
list->length=length;
return value;
}
int list_indexOf(VanList *list,VanWrap *value){
int index=-1;
return index;
}
int list_lastIndexOf(VanList *list,VanWrap *value){
int index=-1;
return index;
}
void list_setValue(VanList *list,int index,VanWrap *value){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *rNode=NULL;
Node *preNode=NULL;
Node *nextNode=NULL;
Node *cur=NULL;
length=list->length;
if(index<length&&index>=0){
head=list->head;
tail=list->tail;
cur=(Node *)calloc(1, sizeof(Node ));
wrap_retain(value);
cur->data=value;
rNode=node_getNodeFromIndex(head, index, length);
preNode=rNode->pre;
nextNode=rNode->next;
preNode->next=cur;
cur->pre=preNode;
cur->next=nextNode;
nextNode->pre=cur;
wrap_release(rNode->data);
free(rNode->userData);
free(rNode);
}
}
VanWrap *list_getValue(VanList *list,int index){
int length=0;
Node *head=NULL;
Node *tail=NULL;
VanWrap *value=NULL;
Node *rNode=NULL;
length=list->length;
if(index<length&&index>=0){
head=list->head;
tail=list->tail;
rNode=node_getNodeFromIndex(head, index, length);
value=rNode->data;
}
return value;
}
char *list_toString(VanList *list){
char *str=NULL;
int len=0;
int length1=128;
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *cur=NULL;
length=list_length(list);
head=list->head;
tail=list->tail;
cur=head->next;
str=(char *)calloc(length1, sizeof(char ));
str[0]='[';
len++;
while(cur!=tail){
int _len=0;
char *_str=NULL;
_str=wrap_toString(cur->data);
_len=strlen(_str);
if(_len+5>=length1-len){
str=realloc(str, length1+_len+5);
length1=length1+_len+5;
}
strcpy(str+len,_str);
len+=_len;
if(cur->next!=tail){
str[len]=',';
len++;
}
cur=cur->next;
}
str[len]=']';
str[len+1]='\0';
return str;
}
void list_free(VanList *list){
}
// map
VanMap *map_create(){
VanMap *map=NULL;
Node *head=NULL;
Node *tail=NULL;
map=(VanMap *)calloc(1, sizeof(VanMap ));
head=(Node *)calloc(1, sizeof(Node ));
tail=(Node *)calloc(1, sizeof(Node ));
head->next=tail;
tail->pre=head;
map->head=head;
map->tail=tail;
return map;
}
int map_length(VanMap *map){
int length=0;
if(map){
length=map->length;
}
return length;
}
void __map_setValue(VanMap *map,char *key,VanWrap *value,int outFlag){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *rNode=NULL;
Node *preNode=NULL;
Node *nextNode=NULL;
Node *cur=NULL;
int flag=-1;
length=map->length;
head=map->head;
tail=map->tail;
cur=(Node *)calloc(1, sizeof(Node ));
wrap_retain(value);
cur->data=value;
rNode=node_getNodeFormKey(head,key,length,&flag);
if(flag>-1){ // 存在
if(rNode->data){
if(rNode->data->type==DataType_RefData&&outFlag){
VanWrap **ref=NULL;
ref=(VanWrap **)rNode->data->data;
*ref=value;
}
else{
rNode->data=value;
}
}
else{
rNode->data=value;
}
// preNode=rNode->pre;
// nextNode=rNode->next;
// preNode->next=cur;
// cur->pre=preNode;
// cur->next=nextNode;
// nextNode->pre=cur;
// wrap_release(rNode->data);
// free(rNode->userData);
// free(rNode);
}
else{
Node *last=NULL;
// cur->userData=key;
cur->userData=(char *)calloc(strlen(key)+1, sizeof(char ));
strcpy((char *)cur->userData,key);
if(length){
last=tail->pre;
last->next=cur;
cur->pre=last;
cur->next=tail;
tail->pre=cur;
}
else{
head->next=cur;
cur->pre=head;
cur->next=tail;
tail->pre=cur;
}
length++;
}
map->length=length;
}
void map_setValue(VanMap *map,char *key,VanWrap *value){
__map_setValue(map,key,value,1);
}
void map_setRefValue(VanMap *map,char *key,VanWrap *value){
__map_setValue(map,key,value,0);
}
VanWrap *map_getValue(VanMap *map,char *key){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *rNode=NULL;
VanWrap *value=NULL;
VanWrap **ref=NULL;
length=map->length;
head=map->head;
tail=map->tail;
rNode=node_getNodeFormKey(head,key,length,NULL);
if(rNode){
value=rNode->data;
if(value){
if(value->type==DataType_RefData){
ref=(VanWrap **)value->data;
value=*ref;
}
}
}
return value;
}
VanWrap *map_getRefValue(VanMap *map,char *key){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *rNode=NULL;
VanWrap *value=NULL;
VanWrap **ref=NULL;
length=map->length;
head=map->head;
tail=map->tail;
rNode=node_getNodeFormKey(head,key,length,NULL);
if(rNode){
ref=&rNode->data;
value=wrap_wrapRefData(ref);
}
return value;
}
int map_hasKey(VanMap *map,char *key){
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *rNode=NULL;
int flag=0;
length=map->length;
head=map->head;
tail=map->tail;
if(length){
rNode=node_getNodeFormKey(head,key,length,&flag);
flag=(flag>-1?1:0);
}
return flag;
}
char **map_keyArr(VanMap *map){
char **keyArr=NULL;
int len=0;
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *cur=NULL;
length=map->length;
head=map->head;
tail=map->tail;
cur=head->next;
if(length){
keyArr=(char **)calloc(length, sizeof(char *));
while(cur!=tail){
char *_key=NULL;
int _len=0;
_key=(char *)cur->userData;
_len=strlen(_key)+1;
keyArr[len]=(char *)calloc(_len+1, sizeof(char ));
strcpy(keyArr[len],_key);
len++;
cur=cur->next;
}
}
return keyArr;
}
VanList *map_valueArr(VanMap *map){
VanList *list=NULL;
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *cur=NULL;
length=map->length;
head=map->head;
tail=map->tail;
cur=head->next;
list=list_create(0);
while(cur!=tail){
list_push(list, cur->data);
cur=cur->next;
}
return list;
}
char *map_toString(VanMap *map){
char *str=NULL;
int len=0;
int length1=128;
int length=0;
Node *head=NULL;
Node *tail=NULL;
Node *cur=NULL;
length=map_length(map);
head=map->head;
tail=map->tail;
cur=head->next;
str=(char *)calloc(length1, sizeof(char ));
str[0]='{';
len++;
while(cur!=tail){
int _len1=0;
int _len2=0;
char *_str1=NULL;
char *_str2=NULL;
_str1=cur->userData;
_len1=strlen(_str1);
_str2=wrap_toString(cur->data);
_len2=strlen(_str2);
if(_len1+_len2+5>=length1-_len1-_len2){
str=realloc(str, length1+_len1+_len2+5);
length1=length1+_len1+_len2+5;
}
strcpy(str+len,_str1);
len+=_len1;
str[len]=':';
len++;
strcpy(str+len,_str2);
len+=_len2;
if(cur->next!=tail){
str[len]=',';
len++;
}
cur=cur->next;
}
str[len]='}';
str[len+1]='\0';
return str;
}
void map_free(VanMap *map){
}
// function
VanFunction *function_create(char *name,char **argNameArr,int *outFlagArr,int length){
VanFunction *func=NULL;
VanMap *dict=NULL;
// VanList *argList=NULL;
// VanMap *upScopeDict=NULL;
// VanMap *globalScopeDict=NULL;
// VanMap *inScopeDict=NULL;
// VanList *chainScopeList=NULL;
func=(VanFunction *)calloc(1, sizeof(VanFunction ));
dict=map_create();
func->name=name;
func->dict=dict;
func->argNameArr=argNameArr;
func->argArrLength=length;
func->outFlagArr=outFlagArr;
// upScopeDict=map_create();
// globalScopeDict=map_create();
// inScopeDict=map_create();
// for(int i=0;i<length;i++){
// map_setValue(inScopeDict, argNameArr[i], NULL);
// }
// argList=list_create(0);
// chainScopeList=list_create(0);
// func->argList=argList;
// func->chainScopeList=chainScopeList;
// func->upScopeDict=upScopeDict;
// func->globalScopeDict=inScopeDict;
// func->inScopeDict=inScopeDict;
return func;
}
void function_bind(VanFunction *func,VanWrap *obj){
if(func&&obj){
wrap_retain(obj);
func->bindObj=obj;
}
}
VanWrap *function_unBind(VanFunction *func){
VanWrap *obj=NULL;
if(func){
wrap_release(func->bindObj);
obj=func->bindObj;
func->bindObj=NULL;
}
return obj;
}
void function_setValue(VanFunction *func,char *key,VanWrap *value){
if(func){
if(func->dict){
map_setValue(func->dict, key, value);
}
}
}
VanWrap *function_getValue(VanFunction *func,char *key){
VanWrap *value=NULL;
if(func){
if(func->dict){
value=map_getValue(func->dict, key);
}
}
return value;
}
void function_setInScopeValue(VanFunction *func,char *name,VanWrap *value){
if(func){
if(func->inScopeDict){
map_setValue(func->inScopeDict, name, value);
}
}
}
VanWrap *function_getInScopeValue(VanFunction *func,char *name){
VanWrap *value=NULL;
if(func){
if(func->inScopeDict){
value=map_getValue(func->inScopeDict, name);
}
}
return value;
}
void function_setUpScopeValue(VanFunction *func,char *name,VanWrap *value){
if(func){
if(func->upScopeDict){
map_setValue(func->upScopeDict, name, value);
}
}
}
VanWrap *function_getUpScopeValue(VanFunction *func,char *name){
VanWrap *value=NULL;
if(func){
if(func->upScopeDict){
value=map_getValue(func->upScopeDict, name);
}
}
return value;
}
char *function_toString(VanFunction *func){
char *str=NULL;
char *str1="function ";
char *str2=NULL;
char *str3="{[code...]}";
int len1=0;
int len2=0;
int len3=0;
str2=func->name;
len1=strlen(str1);
if(str2){
len2=strlen(str2);
}
len3=strlen(str3);
str=(char *)calloc(len1+len2+len3+1, sizeof(char ));
strcpy(str,str1);
if(len2){
strcpy(str+len1,str2);
}
strcpy(str+(len1+len2),str3);
return str;
}
void function_free(VanFunction *func){
}
// class
VanClass *class_create(char *name,VanClass *base){
VanClass *cls=NULL;
VanMap *clsDescDict=NULL;
VanMap *insDescDict=NULL;
VanMap *dict=NULL;
cls=(VanClass *)calloc(1, sizeof(VanClass ));
clsDescDict=map_create();
insDescDict=map_create();
dict=map_create();
cls->name=name;
cls->base=base;
cls->clsDescDict=clsDescDict;
cls->insDescDict=insDescDict;
cls->dict=dict;
return cls;
}
void class_addClsField(VanClass *cls,char *name,VanWrap *value){
if(cls){
if(cls->clsDescDict){
map_setValue(cls->clsDescDict, name, value); // ???
}
}
}
void class_addInsField(VanClass *cls,char *name,VanWrap *value){
if(cls){
if(cls->insDescDict){
map_setValue(cls->insDescDict, name, value); // ???
}
}
}
void class_addClsWrapMethod(VanClass *cls,char *name,FieldDesc desc,int *outFlag,WrapMethod method){
VanWrap *value=NULL;
VanFunction *function=NULL;
function=function_create(NULL, NULL, outFlag, 0);
function->type=FunctionType_NativeFunction;
function->code=method;
value=wrap_wrapFunction(function);
value->_fieldDesc=desc;
class_addClsField(cls,name,value);
}
void class_addInsWrapMethod(VanClass *cls,char *name,FieldDesc desc,int *outFlag,WrapMethod method){
VanWrap *value=NULL;
VanFunction *function=NULL;
function=function_create(NULL, NULL, outFlag, 0);
function->type=FunctionType_NativeFunction;
function->code=method;
value=wrap_wrapFunction(function);
value->_fieldDesc=desc;
class_addInsField(cls,name,value);
}
void class_setValue(VanClass *cls,char *key,VanWrap *value){
VanClass *base=NULL;
VanMap *dict=NULL;
VanMap *clsDescDict=NULL;
int flag=0;
base=cls;
dict=base->dict;
while(base){
clsDescDict=base->clsDescDict;
flag=map_hasKey(clsDescDict, key);
if(flag){ // 成功
map_setValue(dict, key, value);
break;
}
base=base->base;
}
}
VanWrap *class_getValue(VanClass *cls,char *key,int isSuper){
VanWrap *value=NULL;
VanClass *base=NULL;
VanMap *dict=NULL;
VanMap *clsDescDict=NULL;
int flag=0;
base=cls;
if(!isSuper){
while(base){
clsDescDict=base->clsDescDict;
dict=base->dict;
flag=map_hasKey(dict, key);
if(flag){ // ???
value=map_getValue(dict, key);
if(value){
break;
}
}
flag=map_hasKey(clsDescDict, key);
if(flag){ // ???
value=map_getValue(clsDescDict, key);
if(value){
break;
}
}
base=base->base;
}
base=cls; // ???
}
else{
base=base->base;
while(base){
clsDescDict=base->clsDescDict;
dict=base->dict;
flag=map_hasKey(dict, key);
if(flag){ // ???
value=map_getValue(dict, key);
if(value){
base=cls->base; // ???
break;
}
}
flag=map_hasKey(clsDescDict, key);
if(flag){ // ???
value=map_getValue(clsDescDict, key);
if(value){
base=cls->base; // ???
break;
}
}
base=base->base;
}
if(!value){
base=cls;
dict=base->dict;
flag=map_hasKey(dict, key);
if(flag){ // ???
value=map_getValue(dict, key);
}
if(!value){
clsDescDict=cls->clsDescDict;
flag=map_hasKey(clsDescDict, key);
if(flag){ // ???
value=map_getValue(clsDescDict, key);
}
}
}
}
if(value){
if(value->type==DataType_Function){ // bind
VanFunction *_fun=NULL;
_fun=value->data;
function_bind(_fun, wrap_wrapClass(base));
}
}
return value;
}
VanClass *class_base(VanClass *cls){
VanClass *base=NULL;
if(cls){
base=cls->base;
}
return base;
}
char *class_toString(VanClass *cls){
char *str=NULL;
char *str1="class ";
char *str2=NULL;
char *str3="{[code...]}";
int len1=0;
int len2=0;
int len3=0;
str2=cls->name;
len1=strlen(str1);
if(str2){
len2=strlen(str2);
}
len3=strlen(str3);
str=(char *)calloc(len1+len2+len3+1, sizeof(char ));
strcpy(str,str1);
if(len2){
strcpy(str+len1,str2);
}
strcpy(str+(len1+len2),str3);
return str;
}
void class_free(VanClass *cls){
}
// instance
VanWrap *instance_create(VanClass *cls,VanList *argList){
VanWrap *wrap=NULL;
VanInstance *ins=NULL;
VanMap *dict=NULL;
if(cls->type==ClassType_NativeClass){
VanWrap *_value=NULL;
VanFunction *_func=NULL;
WrapMethod _method=NULL;
_value=map_getValue(cls->clsDescDict, "__new__");
if(_value->type==DataType_Function){
_func=_value->data;
if(_func->type==FunctionType_NativeFunction){
_method=_func->code;
wrap=_method(NULL,argList);
}
}
}
else{
ins=(VanInstance *)calloc(1, sizeof(VanInstance ));
dict=map_create();
ins->cls=cls;
ins->dict=dict;
wrap=wrap_wrapInstance(ins);
}
return wrap;
}
void instance_setValue(VanInstance *ins,char *key,VanWrap *value){
VanClass *cls=NULL;
VanMap *dict=NULL;
VanMap *insDescDict=NULL;
int flag=0;
cls=ins->cls;
dict=ins->dict;
while(cls){
insDescDict=cls->insDescDict;
flag=map_hasKey(insDescDict, key);
if(flag){ // 成功
map_setValue(dict, key, value);
break;
}
cls=cls->base;
}
}
VanWrap *instance_getValue(VanInstance *ins,char *key,int isSuper){
VanWrap *value=NULL;
VanClass *cls=NULL;
VanMap *dict=NULL;
VanMap *insDescDict=NULL;
int flag=0;
cls=ins->cls;
dict=ins->dict;
if(!isSuper){
flag=map_hasKey(dict, key);
if(flag){ // ???
value=map_getValue(dict, key);
}
if(!value){
while(cls){
insDescDict=cls->insDescDict;
flag=map_hasKey(insDescDict, key);
if(flag){ // ???
value=map_getValue(insDescDict, key);
if(value){
break;
}
}
cls=cls->base;
}
}
}
else{
cls=cls->base;
while(cls){
insDescDict=cls->insDescDict;
flag=map_hasKey(insDescDict, key);
if(flag){ // ???
value=map_getValue(insDescDict, key);
if(value){
break;
}
}
cls=cls->base;
}
if(!value){
flag=map_hasKey(dict, key);
if(flag){ // ???
value=map_getValue(dict, key);
}
}
if(!value){
cls=ins->cls;
insDescDict=cls->insDescDict;
flag=map_hasKey(insDescDict, key);
if(flag){ // ???
value=map_getValue(insDescDict, key);
}
}
}
if(value){
if(value->type==DataType_Function){ // bind
VanFunction *_fun=NULL;
_fun=value->data;
function_bind(_fun, wrap_wrapInstance(ins));
}
}
return value;
}
VanClass *instance_class(VanInstance *ins){
VanClass *cls=NULL;
if(ins){
cls=ins->cls;
}
return cls;
}
char *instance_toString(VanInstance *ins){
char *str=NULL;
char *str1="object ";
char *str2=NULL;
char *str3="{[code...]}";
int len1=0;
int len2=0;
int len3=0;
str2=ins->cls->name;
len1=strlen(str1);
if(str2){
len2=strlen(str2);
}
len3=strlen(str3);
str=(char *)calloc(len1+len2+len3+1, sizeof(char ));
strcpy(str,str1);
if(len2){
strcpy(str+len1,str2);
}
strcpy(str+(len1+len2),str3);
return str;
}
void instance_free(VanInstance *ins){
}
// wrap
VanWrap *wrap_wrapNull(){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Null;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapTrue(){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_True;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapFalse(){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_False;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapByte(signed char c){
return wrap_wrapLongLong(c);
}
VanWrap *wrap_wrapUByte(unsigned char c){
return wrap_wrapLongLong(c);
}
VanWrap *wrap_wrapShort(short s){
return wrap_wrapLongLong(s);
}
VanWrap *wrap_wrapUShort(unsigned short s){
return wrap_wrapLongLong(s);
}
VanWrap *wrap_wrapInt(int i){
return wrap_wrapLongLong(i);
}
VanWrap *wrap_wrapUInt(unsigned int i){
return wrap_wrapLongLong(i);
}
VanWrap *wrap_wrapLong(long l){
return wrap_wrapLongLong(l);
}
VanWrap *wrap_wrapLongLong(long long l){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Int;
wrap->_referNum=1;
wrap->value.l=l;
return wrap;
}
VanWrap *wrap_wrapFloat(float d){
return wrap_wrapDouble(d);
}
VanWrap *wrap_wrapDouble(double d){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Float;
wrap->_referNum=1;
wrap->value.d=d;
return wrap;
}
VanWrap *wrap_wrapNativeFunction(VanNativeFunction *function){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_NativeFunction;
wrap->data=function;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapOpaquePointer(void *data){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_OpaquePointer;
wrap->data=data;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapString(VanString *str){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_String;
wrap->data=str;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapList(VanList *list){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_List;
wrap->data=list;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapMap(VanMap *map){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Map;
wrap->data=map;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapFunction(VanFunction *func){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Function;
wrap->data=func;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapClass(VanClass *cls){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Class;
wrap->data=cls;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapInstance(VanInstance *ins){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_Instance;
wrap->data=ins;
wrap->_referNum=1;
return wrap;
}
VanWrap *wrap_wrapRefData(VanWrap **data){
VanWrap *wrap=NULL;
wrap=(VanWrap *)calloc(1,sizeof(VanWrap ));
wrap->type=DataType_RefData;
wrap->data=data;
wrap->_referNum=1;
return wrap;
}
void wrap_retain(VanWrap *wrap){
if(wrap){
wrap->_referNum++;
}
}
// 循环引用 ??????
void wrap_release(VanWrap *wrap){
if(wrap){
wrap->_referNum--;
if(!wrap->_referNum){
if(wrap->type==DataType_String){
string_free(wrap->data);
}
else if(wrap->type==DataType_List){
list_free(wrap->data);
}
else if(wrap->type==DataType_Map){
map_free(wrap->data);
}
else if(wrap->type==DataType_Function){
function_free(wrap->data);
}
else if(wrap->type==DataType_Class){
class_free(wrap->data);
}
else if(wrap->type==DataType_Instance){
instance_free(wrap->data);
}
}
}
}
char *wrap_toString(VanWrap * wrap){
char *str=NULL;
if(wrap){
if(wrap->type==DataType_Null){
int _len=0;
char *_str="null";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
else if(wrap->type==DataType_True){
int _len=0;
char *_str="true";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
else if(wrap->type==DataType_False){
int _len=0;
char *_str="false";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
else if(wrap->type==DataType_Int){
str=(char *)calloc(30, sizeof(char ));
sprintf(str, "%lld",wrap->value.l);
}
else if(wrap->type==DataType_Float){
str=(char *)calloc(30, sizeof(char ));
str=gcvt(wrap->value.d, 30, str);
}
else if(wrap->type==DataType_String){
str=string_toString(wrap->data);
}
else if(wrap->type==DataType_List){
str=list_toString(wrap->data);
}
else if(wrap->type==DataType_Map){
str=map_toString(wrap->data);
}
else if(wrap->type==DataType_Function){
str=function_toString(wrap->data);
}
else if(wrap->type==DataType_Class){
str=class_toString(wrap->data);
}
else if(wrap->type==DataType_Instance){
str=instance_toString(wrap->data);
}
else if(wrap->type==DataType_NativeFunction){
int _len=0;
char *_str="NativeFunction";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
else if(wrap->type==DataType_NativeData){
int _len=0;
char *_str="NativeData";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
else if(wrap->type==DataType_OpaquePointer){
int _len=0;
char *_str="OpaquePointer";
_len=strlen(_str)+1;
str=(char *)calloc(_len, sizeof(char ));
strcpy(str,_str);
}
}
return str;
}
static Node *node_getNodeFromIndex(Node *head,int index,int length){
Node *rNode=NULL;
Node *cur=NULL;
cur=head;
for(int i=0;i<length;i++){
cur=cur->next;
if(index==i){
rNode=cur;
break;
}
}
return rNode;
}
static Node *node_getNodeFormKey(Node *head,char *key,int length,int *flag){
Node *rNode=NULL;
Node *cur=NULL;
int _flag=-1;
cur=head;
for(int i=0;i<length;i++){
cur=cur->next;
if(strcmp(key,(char *)cur->userData)==0){
rNode=cur;
_flag=i;
break;
}
}
if(flag){
*flag=_flag;
}
return rNode;
}
|
liufeigit/Van-lang
|
src/van_parseUtil.c
|
<gh_stars>1-10
// clang
#include "van_parseUtil.h"
ASTNode *astNode_getRootNode(ASTNode *node){
ASTNode *rootNode=NULL;
if(node){
rootNode=node;
while(rootNode->parent){
rootNode=rootNode->parent;
}
}
return rootNode;
}
ASTNode *astNode_findLoseNode(ASTNode *node){
ASTNode *loseNode=NULL;
ASTNode **arr=NULL;
if(node){
arr=(ASTNode **)node->childArr;
if(node->op>ASTOp_BinaryStart&&
node->op<ASTOp_BinaryEnd){
if(arr){
for(int i=0;i<node->childLength;i++){
if(!arr[i]){
loseNode=node;
break;
}
}
}
}
if(!loseNode){
for(int i=0;i<node->childLength;i++){
loseNode=astNode_findLoseNode(arr[i]);
if(loseNode){
break;
}
}
}
}
return loseNode;
}
ASTNode *astNode_findBinaryGreaterNode(ASTNode *node,ASTOp op){
ASTNode *greaterNode=NULL;
if(node){
if(node->op>ASTOp_BinaryStart&&
node->op<ASTOp_BinaryEnd){
if(op%10<node->op%10){
greaterNode=node;
}
}
if(!greaterNode){
greaterNode=astNode_findBinaryGreaterNode(node->parent,op);
}
}
return greaterNode;
}
ASTNode *astNode_mergeNode(ASTNode *leftNode,ASTNode *rightNode){
ASTNode *loseNode=NULL;
ASTNode *greaterNode=NULL;
ASTOp op1=0;
ASTOp op2=0;
if(!leftNode){
return rightNode;
}
loseNode=astNode_findLoseNode(leftNode);
op1=loseNode->op;
op2=rightNode->op;
if(op2>ASTOp_BinaryStart&&
op2<ASTOp_BinaryEnd&&
op2%10>=op1%10){ // op2<=op1
greaterNode=astNode_findBinaryGreaterNode(loseNode,op2);
loseNode->childArr[1]=rightNode->childArr[0];
((ASTNode *)loseNode->childArr[1])->parent=loseNode;
if(greaterNode){
rightNode->childArr[0]=greaterNode->childArr[1];
((ASTNode *)rightNode->childArr[0])->parent=rightNode;
greaterNode->childArr[1]=rightNode;
rightNode->parent=greaterNode;
}
else{
rightNode->childArr[0]=leftNode;
leftNode->parent=rightNode;
leftNode=rightNode;
}
}
else{ // op2>op1 || ???
loseNode->childArr[1]=rightNode;
rightNode->parent=loseNode;
}
return leftNode;
}
int astNode_all(ASTNode *node,FlagHander hander){
int length=0;
ASTNode **nodeArr=NULL;
int flag=0;
flag=hander(node);
if(flag){
length=node->childLength;
nodeArr=node->childArr;
for(int i=0;i<length;i++){
flag=astNode_all(nodeArr[i], hander);
if(!flag){
break;
}
}
}
return flag;
}
int astNode_has(ASTNode *node,FlagHander hander){
int length=0;
ASTNode **nodeArr=NULL;
int flag=0;
flag=hander(node);
if(!flag){
length=node->childLength;
nodeArr=node->childArr;
for(int i=0;i<length;i++){
flag=astNode_all(nodeArr[i], hander);
if(flag){
break;
}
}
}
return flag;
}
// class --> new
int astNode_hasNewParent(ASTNode *node){
int flag=0;
ASTNode *parent=NULL;
parent=node->parent;
while(parent){
if(parent->op==ASTOp_New){
flag=1;
break;
}
else if(parent->op==ASTOp_Prior){
parent=parent->parent;
continue;
}
else{
break;
}
}
return flag;
}
// new -->class
int astNode_hasClassChild(ASTNode *node){
int flag=0;
ASTNode **nodeArr=NULL;
nodeArr=node->childArr;
while(nodeArr){
if(nodeArr[0]->op==ASTOp_Call){
if(nodeArr[0]->childArr[0]->wrap->type==DataType_Class){
flag=1;
}
break;
}
else if(nodeArr[0]->op==ASTOp_Prior){
nodeArr=nodeArr[0]->childArr;
continue;
}
else{
break;
}
}
return flag;
}
// 递归线性展开
void astNode_vist(ASTNode *node,VistHandler handler){
}
void astNode_free(ASTNode *node){
}
|
liufeigit/Van-lang
|
src/van_gen.c
|
// clang
#include "van_gen.h"
|
liufeigit/Van-lang
|
src/van_builtin.c
|
// clang
#include "van_builtin.h"
VanWrap *wrap_builtinList(){
VanWrap *wrap=NULL;
VanClass *listClass=NULL;
VanWrap *lengthFunc=NULL;
listClass=class_create("List", NULL);
class_addInsField(listClass, "length", lengthFunc);
return wrap;
}
VanWrap *VanString_new(VanWrap *data){
}
VanWrap *VanString_length(VanWrap *str){
}
VanWrap *VanString_add(VanWrap *str1,VanWrap *str2){
}
VanWrap *VanString_split(VanWrap *str1,VanWrap *data){
}
VanWrap *VanString_setValue(VanWrap *str,VanWrap *c){
}
VanWrap *VanString_getValue(VanWrap *str){
}
VanWrap *VanString_subString(VanWrap *str,VanWrap *start,VanWrap *end){
}
VanWrap *VanString_toString(VanWrap *str){
}
VanWrap *VanString_free(VanWrap *str){
}
VanWrap *VanList_new(VanWrap *length){
}
VanWrap *VanList_length(VanWrap *list){
}
VanWrap *VanList_push(VanWrap *list,VanWrap *value){
}
VanWrap *VanList_pop(VanWrap *list){
}
VanWrap *VanList_indexOf(VanWrap *list,VanWrap *value){
}
VanWrap *VanList_lastIndexOf(VanWrap *list,VanWrap *value){
}
VanWrap *VanList_setValue(VanWrap *list,VanWrap *index,VanWrap *value){
}
VanWrap *VanList_getValue(VanWrap *list,VanWrap *index){
}
VanWrap *VanList_toString(VanWrap *list){
}
VanWrap *VanList_free(VanWrap *list){
}
VanWrap *VanMap_new(){
}
VanWrap *VanMap_length(VanWrap *map){
}
VanWrap *VanMap_setValue(VanWrap *map,VanWrap *key,VanWrap *value){
}
VanWrap *VanMap_getValue(VanWrap *map,VanWrap *key){
}
VanWrap *VanMap_hasKey(VanWrap *map,VanWrap *key){
}
VanWrap *VanMap_keyArr(VanWrap *map){
}
VanWrap *VanMap_valueArr(VanWrap *map){
}
VanWrap *VanMap_toString(VanWrap *map){
}
VanWrap *VanMap_free(VanWrap *map){
}
|
liufeigit/Van-lang
|
src/van_type.c
|
// clang
#include "van_type.h"
// new String(""|true|false|null|1)
VanWrap *VanString_new(VanWrap *self,VanList *arglist){
VanWrap *wStr=NULL;
VanString *vStr=NULL;
char *cStr="";
VanWrap *_arg=NULL;
if(!arglist){
vStr=string_create(cStr);
wStr=wrap_wrapString(vStr);
return wStr;
}
_arg=list_getValue(arglist, 0);
if(_arg->type==DataType_String){
wStr=_arg;
}
else{
cStr=wrap_toString(_arg->data);
vStr=string_create(cStr);
wStr=wrap_wrapString(vStr);
}
return wStr;
}
VanWrap *VanString_length(VanWrap *self,VanList *arglist){
VanString *vStr=NULL;
int length=0;
VanWrap *wLength=NULL;
vStr=self->data;
length=string_length(vStr);
wLength=wrap_wrapLongLong(length);
return wLength;
}
VanWrap *VanString_add(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_split(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_setValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_getValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_subString(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_toString(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanString_free(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanList_new(VanWrap *self,VanList *arglist){
VanWrap *wList=NULL;
VanList *vlist=NULL;
int length=-1;
VanWrap *_arg=NULL;
if(!arglist){
length=0;
}
else{
_arg=list_getValue(arglist, 0);
if(_arg->type==DataType_Int){
length=_arg->value.i2;
}
}
if(length>-1){
vlist=list_create(length);
wList=wrap_wrapList(vlist);
}
return wList;
}
VanWrap *VanList_length(VanWrap *self,VanList *arglist){
VanList *wList=NULL;
int length=0;
VanWrap *wLength=NULL;
wList=self->data;
length=list_length(wList);
wLength=wrap_wrapLongLong(length);
return wLength;
}
VanWrap *VanList_push(VanWrap *self,VanList *arglist){
VanList *vList=NULL;
VanWrap *_arg=NULL;
vList=self->data;
if(!arglist){
return self;
}
_arg=list_getValue(arglist, 0);
list_push(vList,_arg);
return self;
}
VanWrap *VanList_pop(VanWrap *self,VanList *arglist){
VanList *vList=NULL;
VanWrap *wValue=NULL;
vList=self->data;
wValue=list_pop(vList);
return wValue;
}
VanWrap *VanList_indexOf(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanList_lastIndexOf(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanList_setValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanList_getValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanList_toString(VanWrap *self,VanList *arglist){
VanWrap *wStr=NULL;
VanString *vStr=NULL;
char *cStr=NULL;
cStr=wrap_toString(self);
vStr=string_create(cStr);
wStr=wrap_wrapString(vStr);
return wStr;
}
VanWrap *VanList_free(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_new(VanWrap *self,VanList *arglist){
VanWrap *wMap=NULL;
VanMap *vMap=NULL;
vMap=map_create();
wMap=wrap_wrapMap(vMap);
return wMap;
}
VanWrap *VanMap_length(VanWrap *self,VanList *arglist){
VanMap *wMap=NULL;
int length=0;
VanWrap *wLength=NULL;
wMap=self->data;
length=map_length(wMap);
wLength=wrap_wrapLongLong(length);
return wLength;
}
VanWrap *VanMap_setValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_getValue(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_hasKey(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_keyArr(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_valueArr(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_toString(VanWrap *self,VanList *arglist){
return NULL;
}
VanWrap *VanMap_free(VanWrap *self,VanList *arglist){
return NULL;
}
VanClass *wrap_createStringClass(){
VanClass *cls=NULL;
cls=class_create("String",NULL);
cls->type=ClassType_NativeClass;
return cls;
}
VanClass *wrap_createListClass(){
VanClass *cls=NULL;
cls=class_create("List",NULL);
cls->type=ClassType_NativeClass;
class_addClsWrapMethod(cls,"__new__",FieldDesc_IsNull,NULL,VanList_new);
class_addInsWrapMethod(cls,"length",FieldDesc_IsGet,NULL,VanList_length);
class_addInsWrapMethod(cls,"push",FieldDesc_IsNull,NULL,VanList_push);
class_addInsWrapMethod(cls,"pop",FieldDesc_IsNull,NULL,VanList_pop);
class_addInsWrapMethod(cls,"indexOf",FieldDesc_IsNull,NULL,VanList_indexOf);
class_addInsWrapMethod(cls,"lastIndexOf",FieldDesc_IsNull,NULL,VanList_lastIndexOf);
class_addInsWrapMethod(cls,"toString",FieldDesc_IsNull,NULL,VanList_toString);
class_addInsWrapMethod(cls,"__free__",FieldDesc_IsNull,NULL,VanList_free);
return cls;
}
VanClass *wrap_createMapClass(){
VanClass *cls=NULL;
cls=class_create("Map",NULL);
cls->type=ClassType_NativeClass;
class_addClsWrapMethod(cls,"__new__",FieldDesc_IsNull,NULL,VanMap_new);
class_addInsWrapMethod(cls,"length",FieldDesc_IsGet,NULL,VanMap_length);
class_addInsWrapMethod(cls,"hasKey",FieldDesc_IsNull,NULL,VanMap_hasKey);
class_addInsWrapMethod(cls,"keyArr",FieldDesc_IsGet,NULL,VanMap_keyArr);
class_addInsWrapMethod(cls,"valueArr",FieldDesc_IsGet,NULL,VanMap_valueArr);
class_addInsWrapMethod(cls,"toString",FieldDesc_IsNull,NULL,VanMap_toString);
class_addInsWrapMethod(cls,"__free__",FieldDesc_IsNull,NULL,VanMap_free);
return cls;
}
VanClass *wrap_createFunctionClass(){
VanClass *cls=NULL;
cls=class_create("Function",NULL);
cls->type=ClassType_NativeClass;
return cls;
}
VanClass *wrap_createClassClass(){
VanClass *cls=NULL;
cls=class_create("Type",NULL);
cls->type=ClassType_NativeClass;
return cls;
}
VanWrap *wrap_setValueWithKey(VanWrap *wrap,char *key,VanWrap *value){
return NULL;
}
VanWrap *wrap_setValueWithIndex(VanWrap *wrap,int index,VanWrap *value){
return NULL;
}
VanWrap *wrap_getValueWithKey(VanWrap *wrap,char *key){
return NULL;
}
VanWrap *wrap_getValueWithIndex(VanWrap *wrap,int index){
return NULL;
}
|
liufeigit/Van-lang
|
src/enum/van_dataEnum.h
|
#ifndef VAN_DATAENUM_H
#define VAN_DATAENUM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum {
DataType_Null=1,
DataType_True,
DataType_False,
DataType_Int,
DataType_Float,
DataType_String,
DataType_List,
DataType_Map,
DataType_Function,
DataType_Class,
DataType_Instance,
DataType_RefData,
DataType_NativeClass,
DataType_NativeFunction,
DataType_NativeData,
DataType_VoidPointer,
DataType_OpaquePointer,
} DataType;
#ifdef __cplusplus
}
#endif
#endif
|
liufeigit/Van-lang
|
src/van_repl.c
|
// clang
#include "van_lex.h"
#include "van_parse.h"
#include "van_data.h"
#include "van_environ.h"
void execStr(char *data);
int main(int argc,char **argv){
char *fileName=NULL;
FILE *file=NULL;
int len=0;
char *data=NULL;
char str[128];
if(argc<2){
return 0;
}
fileName=argv[1];
file=fopen(fileName, "r");
data=(char *)calloc(100*1024, sizeof(char ));
while(!feof(file)) {
if(fgets(str,128,file)!=NULL){
strncpy(data+len, str, strlen(str));
len+=strlen(str);
}
}
execStr(data);
return 0;
}
void execStr(char *data){
VanEnviron *env=NULL;
int length=0;
Token *token=NULL;
ASTNode *node=NULL;
length=strlen(data);
lexStr(data, &token);
env=environ_create();
if(token){
parseToken(token,&node);
environ_eval(env,node);
}
}
|
liufeigit/Van-lang
|
src/van_lexUtil.c
|
<gh_stars>1-10
// clang
#include "van_lexUtil.h"
Token *filterEmpty(Token *token){
Token *cur=NULL;
cur=token;
while(cur){
if(cur->subType!=TokenSubType_Semicolon){
break;
}
cur=cur->next;
}
return cur;
}
int __calCommaCount(Token *token,Token *end,int flag){
int length=0;
Token *start=NULL;
start=token;
if(!flag){
token=token->next;
}
while(token!=end){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_Comma){ //,
length++;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){ // []
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBracket);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // ()
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightParenth);
if(!token){
break;
}
}
token=token->next;
}
length++;
if(!flag){
if(start->next==end){
length=0;
}
}
return length;
}
int __calMapLength(Token *start,Token *end){
int length=0;
length=__calCommaCount(start,end,0);
return length;
}
int __calListLength(Token *start,Token *end){
int length=0;
length=__calCommaCount(start,end,0);
return length;
}
int __calArgumentsLength(Token *start,Token *end){
int length=0;
length=__calCommaCount(start,end,0);
return length;
}
int __calIfConditionLength(Token *start,Token *end){
int length=0;
Token *token=NULL;
token=start;
end=end->next;
while(token!=end){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // ()
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightParenth);
if(!token){
break;
}
length++;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
token=token->next;
}
return length;
}
int __calIfBlockLength(Token *start,Token *end){
int length=0;
Token *token=NULL;
token=start;
end=end->next;
while(token!=end){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // ()
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightParenth);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
length++;
}
token=token->next;
}
return length;
}
Token *__leftRight(Token *token,TokenType type,TokenSubType subType){
Token *right=NULL;
Token *next=NULL;
TokenType t1;
TokenSubType st1;
if(token){
t1=token->type;
st1=token->subType;
while(token->next){
next=token->next;
if(next->type==type&&next->subType==subType){ // 匹配
right=next;
break;
}
else if(next->type==t1&&next->subType==st1){ // 递归
next=__leftRight(next,type,subType);
if(!next){
break;
}
}
token=next;
}
}
return right;
}
int __isExprState(Token *token){
int flag=1;
return flag;
}
int __isAssignState(Token *token){
int flag=0;
Token *tail=NULL;
Token *end=NULL;
tail=__boundSemicolon(token);
if(!tail){
return flag;
}
end=__boundAssign(token,tail);
if(end){
flag=1;
}
return flag;
}
int __isIfState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_If){
flag=1;
}
return flag;
}
int __isWhileState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_While){
flag=1;
}
return flag;
}
int __isForState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_For){
flag=1;
}
return flag;
}
int __isFunctionState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Def){
if(token->next){
token=token->next;
if(token->subType!=TokenSubType_LeftParenth&&
token->subType!=TokenSubType_LeftBrace){ // TokenType_Identify
flag=1;
}
}
}
return flag;
}
int __isClassState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Class){
if(token->next){
token=token->next;
if(token->subType!=TokenSubType_LeftParenth&&
token->subType!=TokenSubType_LeftBrace){ // TokenType_Identify
flag=1;
}
}
}
return flag;
}
int __isContinueState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Continue){
flag=1;
}
return flag;
}
int __isBreakState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Break){
flag=1;
}
return flag;
}
int __isReturnState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Return){
flag=1;
}
return flag;
}
int __isUpState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Up){
flag=1;
}
return flag;
}
int __isGlobalState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Global){
flag=1;
}
return flag;
}
int __isFieldState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Field){
flag=1;
}
return flag;
}
int __isYieldState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Yield){
flag=1;
}
return flag;
}
int __isStaticState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Static){
flag=1;
}
return flag;
}
int __isImportState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Import){
flag=1;
}
return flag;
}
int __isPrintState(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Print){
flag=1;
}
return flag;
}
// 单值
int __isIdentifiExpr(Token *token){
int flag=0;
if(token->type==TokenType_Identify){
flag=1;
}
return flag;
}
int __isNumberExpr(Token *token){
int flag=0;
if(token->type==TokenType_Literal&&
(token->subType==TokenSubType_Int||
token->subType==TokenSubType_Float)){
flag=1;
}
return flag;
}
int __isNullExpr(Token *token){
int flag=0;
if(token->type==TokenType_Literal&&
token->subType==TokenSubType_Null){
flag=1;
}
return flag;
}
int __isTrueExpr(Token *token){
int flag=0;
if(token->type==TokenType_Literal&&
token->subType==TokenSubType_True){
flag=1;
}
return flag;
}
int __isFalseExpr(Token *token){
int flag=0;
if(token->type==TokenType_Literal&&
token->subType==TokenSubType_False){
flag=1;
}
return flag;
}
int __isSelfExpr(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Self){
flag=1;
}
return flag;
}
int __isSuperExpr(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Super){
flag=1;
}
return flag;
}
int __isStringExpr(Token *token){
int flag=0;
if(token->type==TokenType_Literal&&
token->subType==TokenSubType_String){
flag=1;
}
return flag;
}
// 复合
int __isMapExpr(Token *token){
int flag=0;
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){
flag=1;
}
return flag;
}
int __isListExpr(Token *token){
int flag=0;
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){
flag=1;
}
return flag;
}
int __isFunctionExpr(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Def){
if(token->next){
token=token->next;
if(token->subType==TokenSubType_LeftParenth||
token->subType==TokenSubType_LeftBrace){
flag=1;
}
}
}
return flag;
}
int __isClassExpr(Token *token){
int flag=0;
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_Class){
if(token->next){
token=token->next;
if(token->subType==TokenSubType_LeftParenth||
token->subType==TokenSubType_LeftBrace){
flag=1;
}
}
}
return flag;
}
// 递归
int __isPriorExpr(Token *token){
int flag=0;
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){
flag=1;
}
return flag;
}
int __isNegativeExpr(Token *token){
int flag=0;
if(token->subType==TokenSubType_Sub){
flag=1;
}
return flag;
}
int __isNewExpr(Token *token){
int flag=0;
if(token->subType==TokenSubType_New){
flag=1;
}
return flag;
}
int __isReverseExpr(Token *token){
int flag=0;
if(token->subType==TokenSubType_Reverse){
flag=1;
}
return flag;
}
int __isNotExpr(Token *token){
int flag=0;
if(token->subType==TokenSubType_Not){
flag=1;
}
return flag;
}
Token *__boundBrace(Token *token){
Token *end=NULL;
Token *left=NULL;
while(token){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {
left=token;
break;
}
token=token->next;
}
if(left){
end=__leftRight(left,TokenType_Delimiter,TokenSubType_RightBrace);
}
return end;
}
Token *__boundParenth(Token *token){
Token *end=NULL;
Token *left=NULL;
while(token){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // (
left=token;
break;
}
token=token->next;
}
if(left){
end=__leftRight(left,TokenType_Delimiter,TokenSubType_RightParenth);
}
return end;
}
Token *__boundBracket(Token *token){
Token *end=NULL;
Token *left=NULL;
while(token){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){ // [
left=token;
break;
}
token=token->next;
}
if(left){
end=__leftRight(left,TokenType_Delimiter,TokenSubType_RightBracket);
}
return end;
}
Token *__boundSemicolon(Token *token){
Token *end=NULL;
while(token){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_Semicolon){ // ;
end=token;
break;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
token=token->next;
}
return end;
}
Token *__boundIn(Token *token,Token *tail){
Token *end=NULL;
while(token!=tail){
if(token->type==TokenType_Keyword&&
token->subType==TokenSubType_In){ // ;
end=token;
break;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){ // []
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBracket);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // ()
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightParenth);
if(!token){
break;
}
}
token=token->next;
}
return end;
}
Token *__boundAssign(Token *token,Token *tail){
Token *end=NULL;
while(token!=tail){
if(token->subType>TokenSubType_AssignStart&&
token->subType<TokenSubType_AssignEnd){ // = += *= ...
end=token;
break;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
token=token->next;
}
return end;
}
// ,
Token *__boundComma(Token *token,Token *tail){
Token *end=NULL;
while(token!=tail){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_Comma){ //,
end=token;
break;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){ // []
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBracket);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftParenth){ // ()
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightParenth);
if(!token){
break;
}
}
token=token->next;
}
return end;
}
// :
Token *__boundColon(Token *token,Token *tail){
Token *end=NULL;
while(token!=tail){
if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_Colon){ // :
end=token;
break;
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBrace){ // {}
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBrace);
if(!token){
break;
}
}
else if(token->type==TokenType_Delimiter&&
token->subType==TokenSubType_LeftBracket){ // []
token=__leftRight(token,TokenType_Delimiter,TokenSubType_RightBracket);
if(!token){
break;
}
}
token=token->next;
}
return end;
}
Token *__boundMapExpr(Token *token){
Token *end=NULL;
end=__boundBrace(token);
return end;
}
Token *__boundListExpr(Token *token){
Token *end=NULL;
end=__boundBracket(token);
return end;
}
Token *__boundFunctionExpr(Token *token){
Token *end=NULL;
end=__boundBrace(token);
return end;
}
Token *__boundClassExpr(Token *token){
Token *end=NULL;
end=__boundBrace(token);
return end;
}
Token *__boundMonoExpr(Token *token){
Token *end=NULL;
while(token){
if(!(token->subType==TokenSubType_Sub||
token->subType==TokenSubType_Reverse||
token->subType==TokenSubType_Not||
token->subType==TokenSubType_New)){
end=token->pre;
break;
}
else{
token=token->next;
}
}
return end;
}
Token *__boundExprState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundAssignState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundIfState(Token *token){
Token *end=NULL;
// if
token=__boundParenth(token);
if(!token){
return NULL;
}
token=__boundBrace(token->next);
if(!token){
return NULL;
}
if(token->next){
token=token->next;
while(token){
if(token->subType==TokenSubType_Else&&
token->next){
if(token->next->subType==TokenSubType_If){ // else if
token=__boundParenth(token);
if(token){
token=__boundBrace(token->next);
if(token){
token=token->next;
}
else{
return NULL;
}
}
else{
return NULL;
}
}
else{ // else
token=__boundBrace(token);
if(token){
token=token->next;
}
else{
return NULL;
}
}
}
else{
break;
}
}
end=token->pre;
}
return end;
}
Token *__boundWhileState(Token *token){
Token *end=NULL;
token=__boundParenth(token);
if(!token){
return NULL;
}
end=__boundBrace(token);
if(!end){
return end;
}
return end;
}
Token *__boundForState(Token *token){
Token *end=NULL;
token=__boundParenth(token);
if(!token){
return NULL;
}
end=__boundBrace(token);
if(!end){
return end;
}
return end;
}
Token *__boundFunctionState(Token *token){
Token *end=NULL;
// token=__boundParenth(token);
end=__boundBrace(token);
return end;
}
Token *__boundClassState(Token *token){
Token *end=NULL;
// token=__boundParenth(token);
end=__boundBrace(token);
return end;
}
Token *__boundContinueState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundBreakState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundReturnState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundUpState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundGlobalState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundFieldState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundYieldState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundImportState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
Token *__boundPrintState(Token *token){
Token *end=NULL;
end=__boundSemicolon(token);
return end;
}
|
liufeigit/Van-lang
|
External/extendTest1.c
|
<reponame>liufeigit/Van-lang
// clang -g -fPIC -shared -L. -lvan extendTest1.c -o ./External/libextendTest1.so
#include "../src/van_data.h"
#include "../src/van_environ.h"
void module_init();
int sub(int a,int b);
VanWrap *wrap_sub(VanWrap *self,VanList *argList);
// static/dynamic
void nativeFunction_Load(VanEnviron *env){
VanFunction *func=(VanFunction *)calloc(1, sizeof(VanFunction));
func->name=(char *)calloc(1, strlen("sub")+1);
strcpy(func->name,"sub");
func->code=wrap_sub;
func->type=FunctionType_NativeFunction;
environ_brigeNativeFunction(env, func);
}
int sub(int a,int b){
return a+b;
}
VanWrap *wrap_sub(VanWrap *self,VanList *argList){
VanWrap *result=NULL;
int v=0;
if(list_length(argList)>=2){
v=sub(list_getValue(argList, 0)->value.l,list_getValue(argList, 1)->value.l);
result=wrap_wrapLongLong(v);
printf("sub is %s\n",wrap_toString(result));
}
return result;
}
|
liufeigit/Van-lang
|
src/van_main.c
|
// clang -g van_lex.c van_lexUtil.c van_parse.c van_type.c van_parseUtil.c van_data.c van_dataUtil.c van_environ.c van_environBridge.c van_error.c van_main.c -o van
// clang -g -fPIC -shared van_lex.c van_lexUtil.c van_parse.c van_type.c van_parseUtil.c van_data.c van_dataUtil.c van_environ.c van_environBridge.c van_error.c -o libvan.so
// clang -g van_main.c -L. -lvan -o van
#include "van_lex.h"
#include "van_parse.h"
#include "van_data.h"
#include "van_environ.h"
void execStr(char *data);
int main(int argc,char **argv){
char *fileName=NULL;
FILE *file=NULL;
int len=0;
char *data=NULL;
char str[128];
if(argc<2){
return 0;
}
fileName=argv[1];
file=fopen(fileName, "r");
data=(char *)calloc(100*1024, sizeof(char ));
while(!feof(file)) {
if(fgets(str,128,file)!=NULL){
strncpy(data+len, str, strlen(str));
len+=strlen(str);
}
}
execStr(data);
return 0;
}
void execStr(char *data){
VanEnviron *env=NULL;
int length=0;
Token *token=NULL;
Token *token1=NULL;
ASTNode *node=NULL;
length=strlen(data);
lexStr(data, &token,&token1);
env=environ_create();
if(token){
// tokenDebug(token);
parseToken(token,&node);
// debugASTNode(node);
environ_eval(env,node);
}
}
|
liufeigit/Van-lang
|
src/van_dataUtil.c
|
// clang
#include "van_data.h"
VanWrap *wrap_binaryCal(VanWrap *leftWrap,VanWrap *rightWrap,ASTOp op){
VanWrap *wrap=NULL;
if(leftWrap&&rightWrap){
if((leftWrap->type==DataType_Int||leftWrap->type==DataType_Float)&&
(rightWrap->type==DataType_Int||rightWrap->type==DataType_Float)){
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Int){
if(op==ASTOp_LeftShift){ // <<
wrap=wrap_wrapLongLong(leftWrap->value.l<<rightWrap->value.l);
}
else if(op==ASTOp_RightShift){ // >>
wrap=wrap_wrapLongLong(leftWrap->value.l>>rightWrap->value.l);
}
else if(op==ASTOp_XOr){ // |
wrap=wrap_wrapLongLong(leftWrap->value.l|rightWrap->value.l);
}
else if(op==ASTOp_XAnd){// &
wrap=wrap_wrapLongLong(leftWrap->value.l&rightWrap->value.l);
}
else if(op==ASTOp_XEr){ // ^
wrap=wrap_wrapLongLong(leftWrap->value.l^rightWrap->value.l);
}
else if(op==ASTOp_Mod){// %
wrap=wrap_wrapLongLong(leftWrap->value.l%rightWrap->value.l);
}
}
if(op==ASTOp_Mul){ // *
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.l*rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapDouble(leftWrap->value.d*rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.d*rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l*rightWrap->value.l);
}
}
else if(op==ASTOp_Div){ // /
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.l/rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapDouble(leftWrap->value.d/rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.d/rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l/rightWrap->value.l);
}
}
else if(op==ASTOp_Add){ // +
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.l+rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapDouble(leftWrap->value.d+rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.d+rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l+rightWrap->value.l);
}
}
else if(op==ASTOp_Sub){ // -
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.l-rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapDouble(leftWrap->value.d-rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapDouble(leftWrap->value.d-rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l-rightWrap->value.l);
}
}
else if(op==ASTOp_GR){ // >
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l>rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d>rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d>rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l>rightWrap->value.l);
}
}
else if(op==ASTOp_GE){ // >=
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l>=rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d>=rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d>=rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l>=rightWrap->value.l);
}
}
else if(op==ASTOp_LS){ // <
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l<rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d<rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d<rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l<rightWrap->value.l);
}
}
else if(op==ASTOp_LE){ // <=
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l<=rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d<=rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d<=rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l<=rightWrap->value.l);
}
}
else if(op==ASTOp_EQ){ // ==
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l==rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d==rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d==rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l==rightWrap->value.l);
}
}
else if(op==ASTOp_NE){ // !=
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l!=rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d!=rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d!=rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l!=rightWrap->value.l);
}
}
else if(op==ASTOp_And){ // &&
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l&&rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d&&rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d&&rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l&&rightWrap->value.l);
}
}
else if(op==ASTOp_Or){ // ||
if(leftWrap->type==DataType_Int&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.l||rightWrap->value.d);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Int){
wrap=wrap_wrapLongLong(leftWrap->value.d||rightWrap->value.l);
}
else if(leftWrap->type==DataType_Float&&
rightWrap->type==DataType_Float){
wrap=wrap_wrapLongLong(leftWrap->value.d||rightWrap->value.d);
}
else{ // int
wrap=wrap_wrapLongLong(leftWrap->value.l||rightWrap->value.l);
}
}
}
}
return wrap;
}
|
liufeigit/Van-lang
|
src/van_lex.h
|
#ifndef VAN_LEX_H
#define VAN_LEX_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include "van_enum.h"
typedef struct Token{
TokenType type;
TokenSubType subType;
union {
long long l;
double d;
} value; // int/float
char *data; // indentify/string
struct Token *next;
struct Token *pre;
unsigned int row;
unsigned int column;
} Token;
int lexStr(char *str,Token **headToken,Token **tailToken);
void freeToken(Token *token);
void debugToken(Token *token);
#ifdef __cplusplus
}
#endif
#endif
|
cran/meanr
|
src/score.c
|
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h> // for ispunct()
#include <safeomp.h>
#include <reactor.h>
#include <RNACI.h>
#include "hashtable/poshash.h"
#include "hashtable/neghash.h"
#define THROW_MEMERR() error("unable to allocate memory")
#define FREE(ptr) if(ptr!=NULL) free(ptr)
// ----------------------------------------------------------------------------
// Hashtable interface
// ----------------------------------------------------------------------------
static inline bool is_pos_sentiment(const char *word, const int wordlen)
{
return in_pos_set(word, wordlen) != NULL;
}
static inline bool is_neg_sentiment(const char *word, const int wordlen)
{
return in_neg_set(word, wordlen) != NULL;
}
static inline int8_t get_sentiment_score(const char *word, const int wordlen)
{
if (is_pos_sentiment(word, wordlen))
return 1;
else if (is_neg_sentiment(word, wordlen))
return -1;
else
return 0;
}
// ----------------------------------------------------------------------------
// Finds the necessary size of the temporary storage
// ----------------------------------------------------------------------------
#define SCHED_LEN 64
static inline size_t max_strlen(SEXP s_, const int len, int nthreads)
{
size_t maxlen = 0;
// NOTE the reduction clause is deliberately missing from omp versions < 4,
// OpenMP didn't include max reductions before then.
#ifdef OMP_VER_4
#pragma omp parallel for simd num_threads(nthreads) schedule(static,SCHED_LEN) if(len>OMP_MIN_SIZE) reduction(max:maxlen)
#else
#pragma omp parallel for num_threads(nthreads) schedule(static,SCHED_LEN) if(len>OMP_MIN_SIZE) // no reduction!
#endif
for (int i=0; i<len; i++)
{
const char *const s = STR(s_, i);
size_t tmp = strlen(s) + 1;
#ifndef OMP_VER_4
#pragma omp critical
#endif
if (tmp > maxlen)
maxlen = tmp;
}
return maxlen;
}
// ----------------------------------------------------------------------------
// R interface
// ----------------------------------------------------------------------------
SEXP R_score(SEXP s_, SEXP nthreads_)
{
SEXP ret, ret_names;
SEXP positive, negative, scores, nwords;
CHECK_IS_STRINGS(s_, "s");
CHECK_IS_POSINT(nthreads_, "nthreads");
const int len = LENGTH(s_);
int nthreads = asInteger(nthreads_);
newRvec(positive, len, "int");
newRvec(negative, len, "int");
newRvec(scores, len, "int");
newRvec(nwords, len, "int");
const size_t slen = max_strlen(s_, len, nthreads);
int8_t check = 0;
#pragma omp parallel shared(check) num_threads(nthreads)
{
char *s = NULL;
// NOTE uncomment to simulate oom failure
// if (omp_get_thread_num() != 1)
s = malloc(slen * sizeof(*s));
// all threads tmp space malloc check
#pragma omp atomic// update
check += (s == NULL);
// malloc succeeded
if (!check)
{
#pragma omp for
for (int i=0; i<len; i++)
{
char *in = STR(s_, i);
size_t inlen = strlen(in) + 1;
if (inlen == 1) // STR(s_, i) == ''
{
INTEGER(positive)[i] = 0;
INTEGER(negative)[i] = 0;
INTEGER(scores)[i] = 0;
INTEGER(nwords)[i] = 0;
continue;
}
memcpy(s, in, inlen*sizeof(*s));
SAFE_SIMD
for (size_t j=0; j<inlen; j++)
{
if (ispunct(s[j]))
s[j] = ' ';
s[j] = tolower(s[j]);
}
int *const restrict pos = INTEGER(positive) + i;
int *const restrict neg = INTEGER(negative) + i;
int *const restrict sc = INTEGER(scores) + i;
int *const restrict nw = INTEGER(nwords) + i;
*pos = *neg = *sc = *nw = 0;
uint32_t start = 0;
uint32_t end;
for (uint32_t j=0; j<inlen; j++)
{
if (isspace(s[j]) || s[j] == '\0')
{
(*nw)++;
end = j;
s[end] = '\0'; // for gperf
int8_t score = get_sentiment_score(s+start, end-start);
*(sc) += score;
if (score > 0)
(*pos)++;
else if (score < 0)
(*neg)++;
j++;
while (isspace(s[j]))
j++;
start = j;
}
}
}
}
FREE(s);
}
// malloc failed - should be outside of parallel region for proper error handling
if (check)
THROW_MEMERR();
make_list_names(ret_names, 4, "positive", "negative", "score", "wc");
make_dataframe(ret, RNULL, ret_names, 4, positive, negative, scores, nwords);
unhideGC();
return ret;
}
|
cran/meanr
|
src/meanr_native.c
|
<gh_stars>0
/* Automatically generated. Do not edit by hand. */
#include <R.h>
#include <Rinternals.h>
#include <R_ext/Rdynload.h>
#include <stdlib.h>
extern SEXP R_meanr_nthreads();
extern SEXP R_score(SEXP s_, SEXP nthreads_);
static const R_CallMethodDef CallEntries[] = {
{"R_meanr_nthreads", (DL_FUNC) &R_meanr_nthreads, 0},
{"R_score", (DL_FUNC) &R_score, 2},
{NULL, NULL, 0}
};
void R_init_meanr(DllInfo *dll)
{
R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
R_useDynamicSymbols(dll, FALSE);
}
|
cran/meanr
|
src/hashtable/poshash.h
|
<gh_stars>0
/* C code produced by gperf version 3.0.4 */
/* Command-line: gperf --includes --readonly-tables --pic --hash-function-name=poshash --lookup-function-name=in_pos_set --slot-name=word positive.txt */
/* Computed positions: -k'1-7,9,$' */
#include <stdint.h>
#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
&& ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
&& (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
&& ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
&& ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
&& ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
&& ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
&& ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
&& ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
&& ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
&& ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
&& ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
&& ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
&& ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
&& ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
&& ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
&& ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
&& ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
&& ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
&& ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
&& ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
&& ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
&& ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
/* The character set is not based on ISO-646. */
error "gperf generated tables don't work with this execution character set. Please report a bug to <<EMAIL>>."
#endif
#include <string.h>
#define POS_TOTAL_KEYWORDS 2003
#define POS_MIN_WORD_LENGTH 2
#define POS_MAX_WORD_LENGTH 20
#define POS_MIN_HASH_VALUE 84
#define POS_MAX_HASH_VALUE 37383
/* maximum key range = 37300, duplicates = 0 */
#ifdef __GNUC__
__inline
#else
#ifdef __cplusplus
inline
#endif
#endif
static unsigned int
poshash (str, len)
register const char *str;
register unsigned int len;
{
static const unsigned short asso_values[] =
{
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 0, 37384, 160, 455, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 335, 720, 2045,
10, 5, 30, 1625, 10187, 125, 2138, 829, 1005, 480,
15, 55, 3996, 6787, 95, 0, 25, 70, 7916, 7511,
9857, 3138, 1996, 25, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384, 37384,
37384, 37384, 37384, 37384, 37384, 37384, 37384
};
register int hval = len;
switch (hval)
{
default:
hval += asso_values[(unsigned char)str[8]];
/*FALLTHROUGH*/
case 8:
case 7:
hval += asso_values[(unsigned char)str[6]+1];
/*FALLTHROUGH*/
case 6:
hval += asso_values[(unsigned char)str[5]];
/*FALLTHROUGH*/
case 5:
hval += asso_values[(unsigned char)str[4]+1];
/*FALLTHROUGH*/
case 4:
hval += asso_values[(unsigned char)str[3]];
/*FALLTHROUGH*/
case 3:
hval += asso_values[(unsigned char)str[2]];
/*FALLTHROUGH*/
case 2:
hval += asso_values[(unsigned char)str[1]];
/*FALLTHROUGH*/
case 1:
hval += asso_values[(unsigned char)str[0]+1];
break;
}
return hval + asso_values[(unsigned char)str[len - 1]];
}
#ifdef __GNUC__
__inline
#if defined __GNUC_STDC_INLINE__ || defined __GNUC_GNU_INLINE__
__attribute__ ((__gnu_inline__))
#endif
#endif
static const char *
in_pos_set (str, len)
register const char *str;
register unsigned int len;
{
struct stringpool_t
{
char stringpool_str84[sizeof("zest")];
char stringpool_str94[sizeof("deft")];
char stringpool_str99[sizeof("dote")];
char stringpool_str119[sizeof("cute")];
char stringpool_str121[sizeof("modern")];
char stringpool_str124[sizeof("deference")];
char stringpool_str148[sizeof("endorses")];
char stringpool_str152[sizeof("endorse")];
char stringpool_str158[sizeof("endorsed")];
char stringpool_str164[sizeof("soft")];
char stringpool_str166[sizeof("modest")];
char stringpool_str181[sizeof("endorsement")];
char stringpool_str186[sizeof("refund")];
char stringpool_str188[sizeof("credence")];
char stringpool_str189[sizeof("cure")];
char stringpool_str196[sizeof("restructure")];
char stringpool_str201[sizeof("serene")];
char stringpool_str202[sizeof("restructured")];
char stringpool_str203[sizeof("cuteness")];
char stringpool_str217[sizeof("stunned")];
char stringpool_str218[sizeof("refunded")];
char stringpool_str221[sizeof("entice")];
char stringpool_str224[sizeof("soundness")];
char stringpool_str231[sizeof("refine")];
char stringpool_str232[sizeof("enticed")];
char stringpool_str233[sizeof("hot")];
char stringpool_str242[sizeof("refined")];
char stringpool_str243[sizeof("defender")];
char stringpool_str261[sizeof("contentment")];
char stringpool_str277[sizeof("honored")];
char stringpool_str281[sizeof("honest")];
char stringpool_str283[sizeof("conscientious")];
char stringpool_str285[sizeof("refinement")];
char stringpool_str301[sizeof("soothe")];
char stringpool_str310[sizeof("heros")];
char stringpool_str314[sizeof("refreshed")];
char stringpool_str326[sizeof("tender")];
char stringpool_str332[sizeof("trusted")];
char stringpool_str335[sizeof("trust")];
char stringpool_str339[sizeof("hero")];
char stringpool_str340[sizeof("merit")];
char stringpool_str350[sizeof("honor")];
char stringpool_str361[sizeof("softer")];
char stringpool_str362[sizeof("hottest")];
char stringpool_str379[sizeof("ease")];
char stringpool_str389[sizeof("sane")];
char stringpool_str390[sizeof("eased")];
char stringpool_str395[sizeof("quiet")];
char stringpool_str396[sizeof("cornerstone")];
char stringpool_str400[sizeof("eases")];
char stringpool_str404[sizeof("safe")];
char stringpool_str431[sizeof("meritorious")];
char stringpool_str439[sizeof("efficient")];
char stringpool_str448[sizeof("reassure")];
char stringpool_str449[sizeof("neat")];
char stringpool_str461[sizeof("mature")];
char stringpool_str466[sizeof("reassurance")];
char stringpool_str472[sizeof("quieter")];
char stringpool_str478[sizeof("sturdier")];
char stringpool_str508[sizeof("led")];
char stringpool_str532[sizeof("masters")];
char stringpool_str552[sizeof("neatest")];
char stringpool_str575[sizeof("counter-attacks")];
char stringpool_str583[sizeof("easiness")];
char stringpool_str585[sizeof("steadiness")];
char stringpool_str589[sizeof("dedicated")];
char stringpool_str591[sizeof("earnestness")];
char stringpool_str593[sizeof("handsome")];
char stringpool_str600[sizeof("saint")];
char stringpool_str601[sizeof("master")];
char stringpool_str602[sizeof("reforms")];
char stringpool_str607[sizeof("earnest")];
char stringpool_str609[sizeof("steadiest")];
char stringpool_str613[sizeof("treasure")];
char stringpool_str618[sizeof("reformed")];
char stringpool_str622[sizeof("easiest")];
char stringpool_str636[sizeof("efficacious")];
char stringpool_str655[sizeof("remunerate")];
char stringpool_str660[sizeof("effortless")];
char stringpool_str693[sizeof("resolute")];
char stringpool_str712[sizeof("hearten")];
char stringpool_str716[sizeof("easier")];
char stringpool_str718[sizeof("eminence")];
char stringpool_str722[sizeof("a+")];
char stringpool_str736[sizeof("quaint")];
char stringpool_str749[sizeof("heartfelt")];
char stringpool_str797[sizeof("eminent")];
char stringpool_str801[sizeof("luster")];
char stringpool_str806[sizeof("assure")];
char stringpool_str807[sizeof("smitten")];
char stringpool_str810[sizeof("meticulous")];
char stringpool_str821[sizeof("defeat")];
char stringpool_str822[sizeof("defeats")];
char stringpool_str824[sizeof("resilient")];
char stringpool_str830[sizeof("humor")];
char stringpool_str838[sizeof("defeated")];
char stringpool_str844[sizeof("lead")];
char stringpool_str845[sizeof("entertains")];
char stringpool_str854[sizeof("lean")];
char stringpool_str859[sizeof("entertain")];
char stringpool_str860[sizeof("leads")];
char stringpool_str861[sizeof("afford")];
char stringpool_str909[sizeof("laud")];
char stringpool_str911[sizeof("attune")];
char stringpool_str920[sizeof("adore")];
char stringpool_str926[sizeof("robust")];
char stringpool_str936[sizeof("adored")];
char stringpool_str939[sizeof("entranced")];
char stringpool_str941[sizeof("ardent")];
char stringpool_str942[sizeof("dead-on")];
char stringpool_str976[sizeof("endear")];
char stringpool_str980[sizeof("ardor")];
char stringpool_str1016[sizeof("redeem")];
char stringpool_str1030[sizeof("astonished")];
char stringpool_str1035[sizeof("smart")];
char stringpool_str1049[sizeof("keen")];
char stringpool_str1056[sizeof("reform")];
char stringpool_str1068[sizeof("smartest")];
char stringpool_str1075[sizeof("autonomous")];
char stringpool_str1081[sizeof("humane")];
char stringpool_str1092[sizeof("commend")];
char stringpool_str1106[sizeof("adorer")];
char stringpool_str1112[sizeof("smarter")];
char stringpool_str1123[sizeof("keenness")];
char stringpool_str1126[sizeof("relent")];
char stringpool_str1134[sizeof("dominates")];
char stringpool_str1138[sizeof("dominate")];
char stringpool_str1154[sizeof("dominated")];
char stringpool_str1170[sizeof("kudos")];
char stringpool_str1183[sizeof("steadfastness")];
char stringpool_str1195[sizeof("assurances")];
char stringpool_str1199[sizeof("assurance")];
char stringpool_str1204[sizeof("steadfast")];
char stringpool_str1210[sizeof("miraculous")];
char stringpool_str1214[sizeof("miraculousness")];
char stringpool_str1224[sizeof("danke")];
char stringpool_str1225[sizeof("elite")];
char stringpool_str1228[sizeof("radiance")];
char stringpool_str1230[sizeof("solid")];
char stringpool_str1231[sizeof("relief")];
char stringpool_str1248[sizeof("kindness")];
char stringpool_str1250[sizeof("danken")];
char stringpool_str1257[sizeof("coolest")];
char stringpool_str1271[sizeof("silent")];
char stringpool_str1307[sizeof("radiant")];
char stringpool_str1309[sizeof("noiseless")];
char stringpool_str1310[sizeof("amuse")];
char stringpool_str1351[sizeof("admire")];
char stringpool_str1361[sizeof("clears")];
char stringpool_str1363[sizeof("seamless")];
char stringpool_str1382[sizeof("cleared")];
char stringpool_str1403[sizeof("counter-attack")];
char stringpool_str1404[sizeof("elan")];
char stringpool_str1416[sizeof("substantive")];
char stringpool_str1430[sizeof("clean")];
char stringpool_str1435[sizeof("elate")];
char stringpool_str1442[sizeof("admirer")];
char stringpool_str1446[sizeof("solace")];
char stringpool_str1448[sizeof("like")];
char stringpool_str1451[sizeof("elated")];
char stringpool_str1455[sizeof("clear")];
char stringpool_str1458[sizeof("risk-free")];
char stringpool_str1459[sizeof("liked")];
char stringpool_str1462[sizeof("clearer")];
char stringpool_str1469[sizeof("likes")];
char stringpool_str1473[sizeof("cleanest")];
char stringpool_str1479[sizeof("hale")];
char stringpool_str1495[sizeof("solicitous")];
char stringpool_str1517[sizeof("cleaner")];
char stringpool_str1521[sizeof("salute")];
char stringpool_str1522[sizeof("astonishment")];
char stringpool_str1526[sizeof("talent")];
char stringpool_str1527[sizeof("talents")];
char stringpool_str1539[sizeof("dauntless")];
char stringpool_str1543[sizeof("talented")];
char stringpool_str1553[sizeof("harmless")];
char stringpool_str1565[sizeof("articulate")];
char stringpool_str1568[sizeof("delicate")];
char stringpool_str1571[sizeof("lionhearted")];
char stringpool_str1580[sizeof("monumental")];
char stringpool_str1584[sizeof("clear-cut")];
char stringpool_str1598[sizeof("self-determination")];
char stringpool_str1601[sizeof("stable")];
char stringpool_str1609[sizeof("stainless")];
char stringpool_str1623[sizeof("miracles")];
char stringpool_str1627[sizeof("miracle")];
char stringpool_str1646[sizeof("abound")];
char stringpool_str1662[sizeof("abounds")];
char stringpool_str1671[sizeof("smiles")];
char stringpool_str1675[sizeof("smile")];
char stringpool_str1691[sizeof("affectation")];
char stringpool_str1719[sizeof("fond")];
char stringpool_str1728[sizeof("fun")];
char stringpool_str1739[sizeof("free")];
char stringpool_str1748[sizeof("liberate")];
char stringpool_str1750[sizeof("freed")];
char stringpool_str1756[sizeof("sustainable")];
char stringpool_str1779[sizeof("fine")];
char stringpool_str1798[sizeof("fondness")];
char stringpool_str1811[sizeof("commendable")];
char stringpool_str1813[sizeof("freedoms")];
char stringpool_str1815[sizeof("liberation")];
char stringpool_str1818[sizeof("restructuring")];
char stringpool_str1820[sizeof("admiration")];
char stringpool_str1825[sizeof("kindliness")];
char stringpool_str1828[sizeof("embolden")];
char stringpool_str1851[sizeof("finest")];
char stringpool_str1866[sizeof("streamlined")];
char stringpool_str1870[sizeof("finer")];
char stringpool_str1871[sizeof("affirm")];
char stringpool_str1875[sizeof("noble")];
char stringpool_str1876[sizeof("nimble")];
char stringpool_str1891[sizeof("humble")];
char stringpool_str1908[sizeof("foremost")];
char stringpool_str1913[sizeof("freshest")];
char stringpool_str1923[sizeof("calmness")];
char stringpool_str1935[sizeof("refreshing")];
char stringpool_str1939[sizeof("abundance")];
char stringpool_str1948[sizeof("desiring")];
char stringpool_str1953[sizeof("abundant")];
char stringpool_str1957[sizeof("fresher")];
char stringpool_str1964[sizeof("doubtless")];
char stringpool_str1969[sizeof("strongest")];
char stringpool_str1977[sizeof("stellar")];
char stringpool_str1979[sizeof("fans")];
char stringpool_str1991[sizeof("regard")];
char stringpool_str2003[sizeof("stunning")];
char stringpool_str2008[sizeof("toughest")];
char stringpool_str2013[sizeof("stronger")];
char stringpool_str2014[sizeof("fast")];
char stringpool_str2018[sizeof("enticing")];
char stringpool_str2019[sizeof("feat")];
char stringpool_str2049[sizeof("eagerness")];
char stringpool_str2052[sizeof("tougher")];
char stringpool_str2062[sizeof("slammin")];
char stringpool_str2063[sizeof("honoring")];
char stringpool_str2095[sizeof("eager")];
char stringpool_str2104[sizeof("best")];
char stringpool_str2115[sizeof("first-rate")];
char stringpool_str2117[sizeof("fastest")];
char stringpool_str2118[sizeof("trusting")];
char stringpool_str2134[sizeof("cool")];
char stringpool_str2142[sizeof("surreal")];
char stringpool_str2143[sizeof("err-free")];
char stringpool_str2161[sizeof("secure")];
char stringpool_str2171[sizeof("decent")];
char stringpool_str2178[sizeof("suitable")];
char stringpool_str2191[sizeof("breeze")];
char stringpool_str2198[sizeof("recomend")];
char stringpool_str2199[sizeof("cost-effective")];
char stringpool_str2208[sizeof("carefree")];
char stringpool_str2209[sizeof("dreamland")];
char stringpool_str2211[sizeof("faster")];
char stringpool_str2215[sizeof("bonus")];
char stringpool_str2222[sizeof("interests")];
char stringpool_str2239[sizeof("nice")];
char stringpool_str2246[sizeof("affirmative")];
char stringpool_str2247[sizeof("bonuses")];
char stringpool_str2255[sizeof("boost")];
char stringpool_str2256[sizeof("affirmation")];
char stringpool_str2273[sizeof("fairness")];
char stringpool_str2279[sizeof("fair")];
char stringpool_str2283[sizeof("readable")];
char stringpool_str2286[sizeof("effectiveness")];
char stringpool_str2287[sizeof("effective")];
char stringpool_str2292[sizeof("freedom")];
char stringpool_str2310[sizeof("satisified")];
char stringpool_str2311[sizeof("nicest")];
char stringpool_str2314[sizeof("calm")];
char stringpool_str2326[sizeof("better")];
char stringpool_str2327[sizeof("contribution")];
char stringpool_str2330[sizeof("nicer")];
char stringpool_str2331[sizeof("tingle")];
char stringpool_str2338[sizeof("consistent")];
char stringpool_str2340[sizeof("heartening")];
char stringpool_str2347[sizeof("confident")];
char stringpool_str2349[sizeof("industrious")];
char stringpool_str2377[sizeof("sincere")];
char stringpool_str2379[sizeof("zeal")];
char stringpool_str2397[sizeof("self-satisfaction")];
char stringpool_str2399[sizeof("instructive")];
char stringpool_str2402[sizeof("merriness")];
char stringpool_str2410[sizeof("erudite")];
char stringpool_str2422[sizeof("friendliness")];
char stringpool_str2431[sizeof("first-class")];
char stringpool_str2432[sizeof("correct")];
char stringpool_str2454[sizeof("fame")];
char stringpool_str2459[sizeof("distinctive")];
char stringpool_str2463[sizeof("cure-all")];
char stringpool_str2465[sizeof("famed")];
char stringpool_str2469[sizeof("distinction")];
char stringpool_str2472[sizeof("entertaining")];
char stringpool_str2475[sizeof("heroine")];
char stringpool_str2479[sizeof("heal")];
char stringpool_str2483[sizeof("reaffirmation")];
char stringpool_str2491[sizeof("skilled")];
char stringpool_str2519[sizeof("ebullient")];
char stringpool_str2534[sizeof("desirable")];
char stringpool_str2549[sizeof("renaissance")];
char stringpool_str2551[sizeof("firmer")];
char stringpool_str2560[sizeof("entrancing")];
char stringpool_str2569[sizeof("titillate")];
char stringpool_str2578[sizeof("fearless")];
char stringpool_str2579[sizeof("nourishment")];
char stringpool_str2585[sizeof("affordable")];
char stringpool_str2592[sizeof("adulate")];
char stringpool_str2599[sizeof("hail")];
char stringpool_str2603[sizeof("assuring")];
char stringpool_str2608[sizeof("reaffirm")];
char stringpool_str2609[sizeof("considerate")];
char stringpool_str2617[sizeof("courage")];
char stringpool_str2639[sizeof("toll-free")];
char stringpool_str2642[sizeof("jubilate")];
char stringpool_str2647[sizeof("jubilant")];
char stringpool_str2649[sizeof("honorable")];
char stringpool_str2650[sizeof("irresistible")];
char stringpool_str2655[sizeof("recommendations")];
char stringpool_str2659[sizeof("recommend")];
char stringpool_str2661[sizeof("recommended")];
char stringpool_str2669[sizeof("recommendation")];
char stringpool_str2685[sizeof("courageous")];
char stringpool_str2689[sizeof("courageousness")];
char stringpool_str2696[sizeof("staunchness")];
char stringpool_str2709[sizeof("jubilation")];
char stringpool_str2712[sizeof("satisfies")];
char stringpool_str2722[sizeof("better-known")];
char stringpool_str2730[sizeof("handier")];
char stringpool_str2732[sizeof("satisfied")];
char stringpool_str2736[sizeof("intimate")];
char stringpool_str2740[sizeof("lucid")];
char stringpool_str2766[sizeof("astonishing")];
char stringpool_str2778[sizeof("mesmerizes")];
char stringpool_str2782[sizeof("mesmerize")];
char stringpool_str2788[sizeof("mesmerized")];
char stringpool_str2795[sizeof("delectable")];
char stringpool_str2810[sizeof("hardier")];
char stringpool_str2812[sizeof("remission")];
char stringpool_str2813[sizeof("adorable")];
char stringpool_str2816[sizeof("fluent")];
char stringpool_str2828[sizeof("laudable")];
char stringpool_str2829[sizeof("hallmarks")];
char stringpool_str2835[sizeof("roomier")];
char stringpool_str2862[sizeof("fanfare")];
char stringpool_str2869[sizeof("brainiest")];
char stringpool_str2879[sizeof("sleek")];
char stringpool_str2902[sizeof("flutter")];
char stringpool_str2917[sizeof("merriment")];
char stringpool_str2948[sizeof("educated")];
char stringpool_str2953[sizeof("sensations")];
char stringpool_str2954[sizeof("memorable")];
char stringpool_str2967[sizeof("sensation")];
char stringpool_str2990[sizeof("affectionate")];
char stringpool_str2997[sizeof("affection")];
char stringpool_str3005[sizeof("felicitate")];
char stringpool_str3012[sizeof("attentive")];
char stringpool_str3026[sizeof("cost-saving")];
char stringpool_str3034[sizeof("cajole")];
char stringpool_str3045[sizeof("felicitous")];
char stringpool_str3068[sizeof("reliable")];
char stringpool_str3074[sizeof("adroit")];
char stringpool_str3085[sizeof("bless")];
char stringpool_str3088[sizeof("striking")];
char stringpool_str3104[sizeof("inestimable")];
char stringpool_str3119[sizeof("boom")];
char stringpool_str3128[sizeof("jubiliant")];
char stringpool_str3130[sizeof("congratulations")];
char stringpool_str3131[sizeof("idealize")];
char stringpool_str3132[sizeof("congratulate")];
char stringpool_str3144[sizeof("congratulation")];
char stringpool_str3148[sizeof("admiring")];
char stringpool_str3153[sizeof("amenable")];
char stringpool_str3167[sizeof("flatter")];
char stringpool_str3200[sizeof("immense")];
char stringpool_str3205[sizeof("bliss")];
char stringpool_str3207[sizeof("ennoble")];
char stringpool_str3217[sizeof("restful")];
char stringpool_str3229[sizeof("romanticize")];
char stringpool_str3232[sizeof("selective")];
char stringpool_str3234[sizeof("boundless")];
char stringpool_str3253[sizeof("commitment")];
char stringpool_str3282[sizeof("bolster")];
char stringpool_str3286[sizeof("ilu")];
char stringpool_str3295[sizeof("instrumental")];
char stringpool_str3304[sizeof("afordable")];
char stringpool_str3341[sizeof("blithe")];
char stringpool_str3381[sizeof("acumen")];
char stringpool_str3389[sizeof("remarkable")];
char stringpool_str3396[sizeof("sensible")];
char stringpool_str3417[sizeof("trouble-free")];
char stringpool_str3423[sizeof("elegance")];
char stringpool_str3447[sizeof("quicker")];
char stringpool_str3448[sizeof("hug")];
char stringpool_str3455[sizeof("regal")];
char stringpool_str3471[sizeof("credible")];
char stringpool_str3474[sizeof("skill")];
char stringpool_str3502[sizeof("elegant")];
char stringpool_str3511[sizeof("strong")];
char stringpool_str3515[sizeof("agile")];
char stringpool_str3526[sizeof("serenity")];
char stringpool_str3534[sizeof("tolerable")];
char stringpool_str3554[sizeof("efficiently")];
char stringpool_str3559[sizeof("rock-stars")];
char stringpool_str3562[sizeof("classic")];
char stringpool_str3565[sizeof("tickle")];
char stringpool_str3567[sizeof("amazes")];
char stringpool_str3571[sizeof("amaze")];
char stringpool_str3587[sizeof("amazed")];
char stringpool_str3589[sizeof("matchless")];
char stringpool_str3590[sizeof("deginified")];
char stringpool_str3597[sizeof("durable")];
char stringpool_str3653[sizeof("rock-star")];
char stringpool_str3657[sizeof("hallmark")];
char stringpool_str3660[sizeof("bloom")];
char stringpool_str3665[sizeof("elation")];
char stringpool_str3687[sizeof("blossom")];
char stringpool_str3696[sizeof("retractable")];
char stringpool_str3703[sizeof("breakthroughs")];
char stringpool_str3708[sizeof("rockstars")];
char stringpool_str3715[sizeof("monumentally")];
char stringpool_str3729[sizeof("saintliness")];
char stringpool_str3734[sizeof("admirable")];
char stringpool_str3776[sizeof("tenacity")];
char stringpool_str3780[sizeof("attraction")];
char stringpool_str3786[sizeof("maturity")];
char stringpool_str3800[sizeof("effortlessly")];
char stringpool_str3801[sizeof("easing")];
char stringpool_str3802[sizeof("rockstar")];
char stringpool_str3831[sizeof("tranquil")];
char stringpool_str3837[sizeof("hotcakes")];
char stringpool_str3841[sizeof("hotcake")];
char stringpool_str3851[sizeof("tenderly")];
char stringpool_str3855[sizeof("angel")];
char stringpool_str3871[sizeof("daring")];
char stringpool_str3880[sizeof("beneficent")];
char stringpool_str3898[sizeof("benefits")];
char stringpool_str3904[sizeof("celebrate")];
char stringpool_str3910[sizeof("celebrated")];
char stringpool_str3920[sizeof("tremendously")];
char stringpool_str3922[sizeof("benefit")];
char stringpool_str3937[sizeof("magical")];
char stringpool_str3950[sizeof("meticulously")];
char stringpool_str3959[sizeof("sensational")];
char stringpool_str3974[sizeof("interesting")];
char stringpool_str3978[sizeof("ideal")];
char stringpool_str4000[sizeof("futurestic")];
char stringpool_str4017[sizeof("audible")];
char stringpool_str4018[sizeof("benifits")];
char stringpool_str4033[sizeof("immaculate")];
char stringpool_str4036[sizeof("celebration")];
char stringpool_str4043[sizeof("issue-free")];
char stringpool_str4071[sizeof("bright")];
char stringpool_str4076[sizeof("maturely")];
char stringpool_str4093[sizeof("brighten")];
char stringpool_str4103[sizeof("fragrant")];
char stringpool_str4104[sizeof("brisk")];
char stringpool_str4120[sizeof("futuristic")];
char stringpool_str4122[sizeof("logical")];
char stringpool_str4125[sizeof("tops")];
char stringpool_str4129[sizeof("brightest")];
char stringpool_str4130[sizeof("amazement")];
char stringpool_str4144[sizeof("masterful")];
char stringpool_str4149[sizeof("faultless")];
char stringpool_str4160[sizeof("magic")];
char stringpool_str4169[sizeof("restored")];
char stringpool_str4173[sizeof("brighter")];
char stringpool_str4181[sizeof("redemption")];
char stringpool_str4183[sizeof("sociable")];
char stringpool_str4188[sizeof("nourishing")];
char stringpool_str4196[sizeof("super")];
char stringpool_str4200[sizeof("benefactor")];
char stringpool_str4207[sizeof("affable")];
char stringpool_str4211[sizeof("satisfying")];
char stringpool_str4214[sizeof("record-setting")];
char stringpool_str4217[sizeof("idol")];
char stringpool_str4221[sizeof("succes")];
char stringpool_str4233[sizeof("succeeds")];
char stringpool_str4240[sizeof("enjoys")];
char stringpool_str4242[sizeof("succeed")];
char stringpool_str4246[sizeof("stupendous")];
char stringpool_str4247[sizeof("success")];
char stringpool_str4249[sizeof("successes")];
char stringpool_str4254[sizeof("succeeded")];
char stringpool_str4257[sizeof("luck")];
char stringpool_str4261[sizeof("enjoyed")];
char stringpool_str4281[sizeof("astonishingly")];
char stringpool_str4286[sizeof("indebted")];
char stringpool_str4301[sizeof("affinity")];
char stringpool_str4305[sizeof("concise")];
char stringpool_str4310[sizeof("courteous")];
char stringpool_str4311[sizeof("titillating")];
char stringpool_str4319[sizeof("steadfastly")];
char stringpool_str4321[sizeof("morality")];
char stringpool_str4327[sizeof("tantalize")];
char stringpool_str4329[sizeof("effusion")];
char stringpool_str4334[sizeof("illustrious")];
char stringpool_str4339[sizeof("outshone")];
char stringpool_str4342[sizeof("soulful")];
char stringpool_str4348[sizeof("confidence")];
char stringpool_str4350[sizeof("miraculously")];
char stringpool_str4365[sizeof("sensitive")];
char stringpool_str4376[sizeof("suffices")];
char stringpool_str4380[sizeof("suffice")];
char stringpool_str4381[sizeof("heartily")];
char stringpool_str4385[sizeof("rapt")];
char stringpool_str4386[sizeof("sufficed")];
char stringpool_str4387[sizeof("first-in-class")];
char stringpool_str4398[sizeof("straighten")];
char stringpool_str4399[sizeof("reasoned")];
char stringpool_str4402[sizeof("reclaim")];
char stringpool_str4409[sizeof("outshine")];
char stringpool_str4423[sizeof("straightforward")];
char stringpool_str4424[sizeof("seasoned")];
char stringpool_str4426[sizeof("illumine")];
char stringpool_str4427[sizeof("indulgent")];
char stringpool_str4443[sizeof("ameliorate")];
char stringpool_str4453[sizeof("illuminate")];
char stringpool_str4456[sizeof("heroize")];
char stringpool_str4460[sizeof("satisfactory")];
char stringpool_str4462[sizeof("satisfactorily")];
char stringpool_str4474[sizeof("outsmart")];
char stringpool_str4476[sizeof("rapid")];
char stringpool_str4480[sizeof("sublime")];
char stringpool_str4486[sizeof("oasis")];
char stringpool_str4510[sizeof("relaxed")];
char stringpool_str4516[sizeof("astutely")];
char stringpool_str4520[sizeof("ebullience")];
char stringpool_str4523[sizeof("stunningly")];
char stringpool_str4524[sizeof("mesmerizing")];
char stringpool_str4536[sizeof("ardently")];
char stringpool_str4538[sizeof("enticingly")];
char stringpool_str4546[sizeof("triumphant")];
char stringpool_str4555[sizeof("fecilitous")];
char stringpool_str4565[sizeof("tenacious")];
char stringpool_str4569[sizeof("cleanliness")];
char stringpool_str4573[sizeof("illuminati")];
char stringpool_str4582[sizeof("resplendent")];
char stringpool_str4603[sizeof("stirringly")];
char stringpool_str4613[sizeof("alluring")];
char stringpool_str4617[sizeof("spontaneous")];
char stringpool_str4618[sizeof("soothingly")];
char stringpool_str4619[sizeof("spotless")];
char stringpool_str4621[sizeof("humility")];
char stringpool_str4626[sizeof("reputation")];
char stringpool_str4635[sizeof("solicitously")];
char stringpool_str4638[sizeof("trustingly")];
char stringpool_str4640[sizeof("momentous")];
char stringpool_str4641[sizeof("delicacy")];
char stringpool_str4651[sizeof("tempt")];
char stringpool_str4654[sizeof("brilliant")];
char stringpool_str4666[sizeof("flourishing")];
char stringpool_str4704[sizeof("comprehensive")];
char stringpool_str4715[sizeof("flattering")];
char stringpool_str4723[sizeof("solidarity")];
char stringpool_str4727[sizeof("adulation")];
char stringpool_str4728[sizeof("adjustable")];
char stringpool_str4733[sizeof("handsomely")];
char stringpool_str4738[sizeof("supreme")];
char stringpool_str4752[sizeof("amiable")];
char stringpool_str4768[sizeof("comfort")];
char stringpool_str4797[sizeof("state-of-the-art")];
char stringpool_str4803[sizeof("enjoyment")];
char stringpool_str4824[sizeof("surmount")];
char stringpool_str4828[sizeof("dazzle")];
char stringpool_str4839[sizeof("dazzled")];
char stringpool_str4845[sizeof("facilitate")];
char stringpool_str4857[sizeof("aspire")];
char stringpool_str4861[sizeof("likable")];
char stringpool_str4870[sizeof("liking")];
char stringpool_str4873[sizeof("agreeableness")];
char stringpool_str4874[sizeof("agreeable")];
char stringpool_str4892[sizeof("sustainability")];
char stringpool_str4893[sizeof("blessing")];
char stringpool_str4909[sizeof("reachable")];
char stringpool_str4929[sizeof("magnanimous")];
char stringpool_str4935[sizeof("fertile")];
char stringpool_str4938[sizeof("surpass")];
char stringpool_str4939[sizeof("blameless")];
char stringpool_str4944[sizeof("commendably")];
char stringpool_str4967[sizeof("ecstasies")];
char stringpool_str4982[sizeof("accomodative")];
char stringpool_str4986[sizeof("salutary")];
char stringpool_str4991[sizeof("ergonomical")];
char stringpool_str5022[sizeof("bargain")];
char stringpool_str5032[sizeof("angelic")];
char stringpool_str5039[sizeof("slick")];
char stringpool_str5061[sizeof("elatedly")];
char stringpool_str5067[sizeof("complements")];
char stringpool_str5078[sizeof("complemented")];
char stringpool_str5091[sizeof("complement")];
char stringpool_str5102[sizeof("cooperative")];
char stringpool_str5116[sizeof("subsidizes")];
char stringpool_str5120[sizeof("subsidize")];
char stringpool_str5126[sizeof("subsidized")];
char stringpool_str5141[sizeof("romantic")];
char stringpool_str5169[sizeof("simplest")];
char stringpool_str5174[sizeof("judicious")];
char stringpool_str5180[sizeof("beneficial")];
char stringpool_str5187[sizeof("helped")];
char stringpool_str5202[sizeof("best-selling")];
char stringpool_str5211[sizeof("compliment")];
char stringpool_str5213[sizeof("simpler")];
char stringpool_str5276[sizeof("modesty")];
char stringpool_str5280[sizeof("delicious")];
char stringpool_str5297[sizeof("transparent")];
char stringpool_str5298[sizeof("accurate")];
char stringpool_str5303[sizeof("amicable")];
char stringpool_str5312[sizeof("aspirations")];
char stringpool_str5316[sizeof("feasible")];
char stringpool_str5325[sizeof("successful")];
char stringpool_str5326[sizeof("aspiration")];
char stringpool_str5334[sizeof("edify")];
char stringpool_str5349[sizeof("merry")];
char stringpool_str5350[sizeof("fastest-growing")];
char stringpool_str5359[sizeof("compassionate")];
char stringpool_str5366[sizeof("compassion")];
char stringpool_str5374[sizeof("nifty")];
char stringpool_str5391[sizeof("honesty")];
char stringpool_str5422[sizeof("effectively")];
char stringpool_str5453[sizeof("consistently")];
char stringpool_str5472[sizeof("comfortable")];
char stringpool_str5489[sizeof("ready")];
char stringpool_str5498[sizeof("loyal")];
char stringpool_str5507[sizeof("endorsing")];
char stringpool_str5516[sizeof("dotingly")];
char stringpool_str5541[sizeof("friendly")];
char stringpool_str5542[sizeof("superb")];
char stringpool_str5586[sizeof("fidelity")];
char stringpool_str5592[sizeof("lucrative")];
char stringpool_str5607[sizeof("supurb")];
char stringpool_str5608[sizeof("strikingly")];
char stringpool_str5616[sizeof("luckiness")];
char stringpool_str5624[sizeof("handy")];
char stringpool_str5625[sizeof("luckiest")];
char stringpool_str5634[sizeof("ebulliently")];
char stringpool_str5638[sizeof("halcyon")];
char stringpool_str5641[sizeof("mastery")];
char stringpool_str5668[sizeof("admiringly")];
char stringpool_str5669[sizeof("luckier")];
char stringpool_str5671[sizeof("sagacity")];
char stringpool_str5675[sizeof("lyrical")];
char stringpool_str5678[sizeof("self-respect")];
char stringpool_str5694[sizeof("accolades")];
char stringpool_str5695[sizeof("dynamic")];
char stringpool_str5698[sizeof("accolade")];
char stringpool_str5704[sizeof("hardy")];
char stringpool_str5706[sizeof("satisfy")];
char stringpool_str5708[sizeof("enterprising")];
char stringpool_str5714[sizeof("comfy")];
char stringpool_str5718[sizeof("affordably")];
char stringpool_str5720[sizeof("hilarious")];
char stringpool_str5729[sizeof("roomy")];
char stringpool_str5776[sizeof("securely")];
char stringpool_str5783[sizeof("irresistibly")];
char stringpool_str5809[sizeof("intimacy")];
char stringpool_str5816[sizeof("dependable")];
char stringpool_str5825[sizeof("courageously")];
char stringpool_str5826[sizeof("titillatingly")];
char stringpool_str5828[sizeof("intelligence")];
char stringpool_str5840[sizeof("qualified")];
char stringpool_str5847[sizeof("intelligent")];
char stringpool_str5866[sizeof("daringly")];
char stringpool_str5868[sizeof("balanced")];
char stringpool_str5875[sizeof("succeeding")];
char stringpool_str5907[sizeof("congenial")];
char stringpool_str5925[sizeof("compliant")];
char stringpool_str5927[sizeof("redeeming")];
char stringpool_str5948[sizeof("intelligible")];
char stringpool_str5961[sizeof("laudably")];
char stringpool_str5967[sizeof("reforming")];
char stringpool_str6017[sizeof("long-lasting")];
char stringpool_str6024[sizeof("bountiful")];
char stringpool_str6039[sizeof("mesmerizingly")];
char stringpool_str6047[sizeof("enjoying")];
char stringpool_str6069[sizeof("tantalizing")];
char stringpool_str6075[sizeof("illuminating")];
char stringpool_str6091[sizeof("reasonable")];
char stringpool_str6092[sizeof("tranquility")];
char stringpool_str6094[sizeof("sensationally")];
char stringpool_str6105[sizeof("dignified")];
char stringpool_str6111[sizeof("felicity")];
char stringpool_str6143[sizeof("formidable")];
char stringpool_str6145[sizeof("buoyant")];
char stringpool_str6151[sizeof("frugal")];
char stringpool_str6178[sizeof("respect")];
char stringpool_str6187[sizeof("defeating")];
char stringpool_str6201[sizeof("reliably")];
char stringpool_str6206[sizeof("respite")];
char stringpool_str6229[sizeof("rational")];
char stringpool_str6230[sizeof("flatteringly")];
char stringpool_str6237[sizeof("inestimably")];
char stringpool_str6241[sizeof("ample")];
char stringpool_str6245[sizeof("ambitious")];
char stringpool_str6265[sizeof("fancier")];
char stringpool_str6267[sizeof("congratulatory")];
char stringpool_str6272[sizeof("endearing")];
char stringpool_str6279[sizeof("masterfully")];
char stringpool_str6294[sizeof("beautiful")];
char stringpool_str6308[sizeof("innocuous")];
char stringpool_str6312[sizeof("outstanding")];
char stringpool_str6316[sizeof("soundly")];
char stringpool_str6318[sizeof("magnificence")];
char stringpool_str6328[sizeof("inpressed")];
char stringpool_str6335[sizeof("rosy")];
char stringpool_str6337[sizeof("magnificent")];
char stringpool_str6362[sizeof("reconcile")];
char stringpool_str6386[sizeof("comforting")];
char stringpool_str6394[sizeof("fulfillment")];
char stringpool_str6405[sizeof("stabilize")];
char stringpool_str6423[sizeof("rejoice")];
char stringpool_str6428[sizeof("indulgence")];
char stringpool_str6434[sizeof("tempting")];
char stringpool_str6446[sizeof("courtly")];
char stringpool_str6452[sizeof("spirited")];
char stringpool_str6467[sizeof("significant")];
char stringpool_str6472[sizeof("trendy")];
char stringpool_str6485[sizeof("tidy")];
char stringpool_str6489[sizeof("amity")];
char stringpool_str6496[sizeof("liberty")];
char stringpool_str6497[sizeof("reconciliation")];
char stringpool_str6502[sizeof("sturdy")];
char stringpool_str6503[sizeof("sparkle")];
char stringpool_str6514[sizeof("heroic")];
char stringpool_str6515[sizeof("triumphal")];
char stringpool_str6522[sizeof("remarkably")];
char stringpool_str6526[sizeof("sufficient")];
char stringpool_str6529[sizeof("sensibly")];
char stringpool_str6535[sizeof("beauteous")];
char stringpool_str6540[sizeof("reputable")];
char stringpool_str6568[sizeof("intuitive")];
char stringpool_str6573[sizeof("romantically")];
char stringpool_str6580[sizeof("accessable")];
char stringpool_str6586[sizeof("stately")];
char stringpool_str6587[sizeof("trusty")];
char stringpool_str6624[sizeof("terrific")];
char stringpool_str6625[sizeof("dazzling")];
char stringpool_str6633[sizeof("enjoyable")];
char stringpool_str6645[sizeof("easy")];
char stringpool_str6651[sizeof("brilliances")];
char stringpool_str6655[sizeof("brilliance")];
char stringpool_str6669[sizeof("adroitly")];
char stringpool_str6677[sizeof("steady")];
char stringpool_str6704[sizeof("acclaimed")];
char stringpool_str6716[sizeof("saintly")];
char stringpool_str6723[sizeof("fearlessly")];
char stringpool_str6734[sizeof("majestic")];
char stringpool_str6744[sizeof("rectification")];
char stringpool_str6750[sizeof("contrasty")];
char stringpool_str6759[sizeof("traction")];
char stringpool_str6767[sizeof("jubilantly")];
char stringpool_str6771[sizeof("impress")];
char stringpool_str6773[sizeof("impresses")];
char stringpool_str6777[sizeof("remedy")];
char stringpool_str6793[sizeof("impressed")];
char stringpool_str6860[sizeof("earnestly")];
char stringpool_str6862[sizeof("subsidizing")];
char stringpool_str6871[sizeof("simplifies")];
char stringpool_str6875[sizeof("competitive")];
char stringpool_str6881[sizeof("simplified")];
char stringpool_str6882[sizeof("respectable")];
char stringpool_str6889[sizeof("fantastic")];
char stringpool_str6897[sizeof("fascinate")];
char stringpool_str6909[sizeof("obsessions")];
char stringpool_str6913[sizeof("razor-sharp")];
char stringpool_str6923[sizeof("obsession")];
char stringpool_str6938[sizeof("affability")];
char stringpool_str6941[sizeof("pros")];
char stringpool_str6966[sizeof("pure")];
char stringpool_str6974[sizeof("nobly")];
char stringpool_str6989[sizeof("fiery")];
char stringpool_str7007[sizeof("poise")];
char stringpool_str7023[sizeof("poised")];
char stringpool_str7027[sizeof("proud")];
char stringpool_str7029[sizeof("fascination")];
char stringpool_str7030[sizeof("prudence")];
char stringpool_str7036[sizeof("ecstatic")];
char stringpool_str7057[sizeof("pride")];
char stringpool_str7074[sizeof("prefers")];
char stringpool_str7080[sizeof("preferes")];
char stringpool_str7085[sizeof("assuredly")];
char stringpool_str7089[sizeof("celebratory")];
char stringpool_str7090[sizeof("prefered")];
char stringpool_str7109[sizeof("prudent")];
char stringpool_str7124[sizeof("crisper")];
char stringpool_str7133[sizeof("alluringly")];
char stringpool_str7137[sizeof("preeminent")];
char stringpool_str7143[sizeof("prefer")];
char stringpool_str7151[sizeof("smartly")];
char stringpool_str7157[sizeof("safely")];
char stringpool_str7161[sizeof("infallible")];
char stringpool_str7162[sizeof("acclaim")];
char stringpool_str7163[sizeof("joy")];
char stringpool_str7168[sizeof("immaculately")];
char stringpool_str7181[sizeof("fast-paced")];
char stringpool_str7182[sizeof("neatly")];
char stringpool_str7195[sizeof("intricate")];
char stringpool_str7203[sizeof("harmonize")];
char stringpool_str7216[sizeof("dirt-cheap")];
char stringpool_str7219[sizeof("realizable")];
char stringpool_str7231[sizeof("respectful")];
char stringpool_str7249[sizeof("commodious")];
char stringpool_str7252[sizeof("splendid")];
char stringpool_str7264[sizeof("harmonious")];
char stringpool_str7269[sizeof("bonny")];
char stringpool_str7299[sizeof("mercy")];
char stringpool_str7304[sizeof("masterpieces")];
char stringpool_str7308[sizeof("masterpiece")];
char stringpool_str7312[sizeof("comely")];
char stringpool_str7314[sizeof("beneficiary")];
char stringpool_str7315[sizeof("beneficially")];
char stringpool_str7318[sizeof("enrapt")];
char stringpool_str7321[sizeof("dead-cheap")];
char stringpool_str7329[sizeof("destiny")];
char stringpool_str7332[sizeof("hooray")];
char stringpool_str7340[sizeof("patience")];
char stringpool_str7368[sizeof("hopeful")];
char stringpool_str7377[sizeof("enjoy")];
char stringpool_str7383[sizeof("praise")];
char stringpool_str7384[sizeof("idolize")];
char stringpool_str7386[sizeof("stupendously")];
char stringpool_str7390[sizeof("idolized")];
char stringpool_str7408[sizeof("compact")];
char stringpool_str7410[sizeof("peerless")];
char stringpool_str7419[sizeof("patient")];
char stringpool_str7421[sizeof("beautify")];
char stringpool_str7422[sizeof("backbone")];
char stringpool_str7436[sizeof("engrossing")];
char stringpool_str7442[sizeof("timely")];
char stringpool_str7446[sizeof("conciliate")];
char stringpool_str7456[sizeof("amiabily")];
char stringpool_str7460[sizeof("successfully")];
char stringpool_str7465[sizeof("holy")];
char stringpool_str7473[sizeof("important")];
char stringpool_str7483[sizeof("amiability")];
char stringpool_str7491[sizeof("incredible")];
char stringpool_str7501[sizeof("clearly")];
char stringpool_str7530[sizeof("adaptable")];
char stringpool_str7556[sizeof("cleanly")];
char stringpool_str7584[sizeof("tantalizingly")];
char stringpool_str7592[sizeof("imaginative")];
char stringpool_str7597[sizeof("spectacular")];
char stringpool_str7609[sizeof("trumpet")];
char stringpool_str7646[sizeof("sweet")];
char stringpool_str7652[sizeof("realistic")];
char stringpool_str7657[sizeof("classy")];
char stringpool_str7661[sizeof("triumphantly")];
char stringpool_str7670[sizeof("sweetness")];
char stringpool_str7684[sizeof("majesty")];
char stringpool_str7686[sizeof("justly")];
char stringpool_str7698[sizeof("sweeten")];
char stringpool_str7705[sizeof("tenaciously")];
char stringpool_str7720[sizeof("paradise")];
char stringpool_str7734[sizeof("eyecatching")];
char stringpool_str7736[sizeof("all-around")];
char stringpool_str7766[sizeof("pain-free")];
char stringpool_str7768[sizeof("capable")];
char stringpool_str7769[sizeof("brilliantly")];
char stringpool_str7780[sizeof("painless")];
char stringpool_str7787[sizeof("speedily")];
char stringpool_str7791[sizeof("swift")];
char stringpool_str7792[sizeof("keenly")];
char stringpool_str7815[sizeof("swiftness")];
char stringpool_str7827[sizeof("outstandingly")];
char stringpool_str7834[sizeof("effusive")];
char stringpool_str7848[sizeof("effusiveness")];
char stringpool_str7877[sizeof("reward")];
char stringpool_str7885[sizeof("dawn")];
char stringpool_str7886[sizeof("acclamation")];
char stringpool_str7889[sizeof("rectifying")];
char stringpool_str7898[sizeof("pluses")];
char stringpool_str7913[sizeof("ingenuous")];
char stringpool_str7917[sizeof("kindly")];
char stringpool_str7924[sizeof("plusses")];
char stringpool_str7942[sizeof("revere")];
char stringpool_str7954[sizeof("venerate")];
char stringpool_str7961[sizeof("ecstasy")];
char stringpool_str7968[sizeof("ingenious")];
char stringpool_str7986[sizeof("fantastically")];
char stringpool_str7998[sizeof("accessible")];
char stringpool_str8005[sizeof("reverence")];
char stringpool_str8013[sizeof("resound")];
char stringpool_str8019[sizeof("reverent")];
char stringpool_str8033[sizeof("jolly")];
char stringpool_str8050[sizeof("understandable")];
char stringpool_str8056[sizeof("terrifically")];
char stringpool_str8058[sizeof("polite")];
char stringpool_str8065[sizeof("easy-to-use")];
char stringpool_str8069[sizeof("magnanimously")];
char stringpool_str8073[sizeof("unencumbered")];
char stringpool_str8079[sizeof("hospitable")];
char stringpool_str8105[sizeof("openness")];
char stringpool_str8107[sizeof("feisty")];
char stringpool_str8112[sizeof("politeness")];
char stringpool_str8114[sizeof("desirous")];
char stringpool_str8116[sizeof("unfettered")];
char stringpool_str8120[sizeof("top")];
char stringpool_str8126[sizeof("resourcefulness")];
char stringpool_str8141[sizeof("eagerly")];
char stringpool_str8154[sizeof("outdone")];
char stringpool_str8157[sizeof("outdo")];
char stringpool_str8160[sizeof("stellarly")];
char stringpool_str8164[sizeof("creative")];
char stringpool_str8165[sizeof("motivated")];
char stringpool_str8183[sizeof("entrust")];
char stringpool_str8184[sizeof("pleased")];
char stringpool_str8194[sizeof("pleases")];
char stringpool_str8203[sizeof("constructive")];
char stringpool_str8204[sizeof("problem-free")];
char stringpool_str8207[sizeof("complementary")];
char stringpool_str8211[sizeof("hands-down")];
char stringpool_str8226[sizeof("best-performing")];
char stringpool_str8237[sizeof("cooperatively")];
char stringpool_str8240[sizeof("pleasure")];
char stringpool_str8242[sizeof("divine")];
char stringpool_str8244[sizeof("awe")];
char stringpool_str8260[sizeof("awed")];
char stringpool_str8266[sizeof("problem-solver")];
char stringpool_str8317[sizeof("awsome")];
char stringpool_str8318[sizeof("helpful")];
char stringpool_str8320[sizeof("superior")];
char stringpool_str8323[sizeof("kid-friendly")];
char stringpool_str8324[sizeof("scenic")];
char stringpool_str8327[sizeof("complimentary")];
char stringpool_str8329[sizeof("low-cost")];
char stringpool_str8341[sizeof("cozy")];
char stringpool_str8348[sizeof("unfazed")];
char stringpool_str8358[sizeof("truthfulness")];
char stringpool_str8375[sizeof("stylized")];
char stringpool_str8381[sizeof("saver")];
char stringpool_str8386[sizeof("suave")];
char stringpool_str8398[sizeof("spellbind")];
char stringpool_str8409[sizeof("standout")];
char stringpool_str8424[sizeof("inspire")];
char stringpool_str8429[sizeof("beautifully")];
char stringpool_str8430[sizeof("beautifullly")];
char stringpool_str8436[sizeof("amicably")];
char stringpool_str8440[sizeof("top-quality")];
char stringpool_str8441[sizeof("statuesque")];
char stringpool_str8442[sizeof("superbly")];
char stringpool_str8444[sizeof("compatible")];
char stringpool_str8447[sizeof("heaven")];
char stringpool_str8449[sizeof("feasibly")];
char stringpool_str8464[sizeof("covenant")];
char stringpool_str8465[sizeof("love")];
char stringpool_str8467[sizeof("fondly")];
char stringpool_str8468[sizeof("ecstatically")];
char stringpool_str8476[sizeof("loved")];
char stringpool_str8486[sizeof("loves")];
char stringpool_str8494[sizeof("merrily")];
char stringpool_str8507[sizeof("supurbly")];
char stringpool_str8524[sizeof("amenity")];
char stringpool_str8531[sizeof("consummate")];
char stringpool_str8532[sizeof("finely")];
char stringpool_str8537[sizeof("replaceable")];
char stringpool_str8554[sizeof("lustrous")];
char stringpool_str8556[sizeof("lover")];
char stringpool_str8563[sizeof("lucky")];
char stringpool_str8580[sizeof("pleasant")];
char stringpool_str8583[sizeof("supple")];
char stringpool_str8591[sizeof("regally")];
char stringpool_str8600[sizeof("progress")];
char stringpool_str8605[sizeof("comfortably")];
char stringpool_str8610[sizeof("yay")];
char stringpool_str8617[sizeof("simplifying")];
char stringpool_str8634[sizeof("readily")];
char stringpool_str8635[sizeof("brotherly")];
char stringpool_str8639[sizeof("fascinating")];
char stringpool_str8650[sizeof("sincerely")];
char stringpool_str8654[sizeof("fancinating")];
char stringpool_str8661[sizeof("notably")];
char stringpool_str8665[sizeof("revolutionizes")];
char stringpool_str8669[sizeof("revolutionize")];
char stringpool_str8672[sizeof("awards")];
char stringpool_str8675[sizeof("revolutionized")];
char stringpool_str8678[sizeof("snazzy")];
char stringpool_str8681[sizeof("award")];
char stringpool_str8685[sizeof("correctly")];
char stringpool_str8692[sizeof("preferring")];
char stringpool_str8693[sizeof("awarded")];
char stringpool_str8709[sizeof("humorous")];
char stringpool_str8710[sizeof("lifesaver")];
char stringpool_str8716[sizeof("sumptuous")];
char stringpool_str8720[sizeof("sumptuousness")];
char stringpool_str8733[sizeof("progressive")];
char stringpool_str8749[sizeof("clarity")];
char stringpool_str8752[sizeof("sagely")];
char stringpool_str8753[sizeof("astound")];
char stringpool_str8765[sizeof("astounded")];
char stringpool_str8768[sizeof("enliven")];
char stringpool_str8769[sizeof("handily")];
char stringpool_str8782[sizeof("preferable")];
char stringpool_str8785[sizeof("avid")];
char stringpool_str8795[sizeof("optimism")];
char stringpool_str8807[sizeof("beauty")];
char stringpool_str8814[sizeof("qualify")];
char stringpool_str8819[sizeof("civilize")];
char stringpool_str8822[sizeof("catchy")];
char stringpool_str8835[sizeof("aver")];
char stringpool_str8842[sizeof("humour")];
char stringpool_str8871[sizeof("lucidly")];
char stringpool_str8891[sizeof("revelation")];
char stringpool_str8895[sizeof("portable")];
char stringpool_str8937[sizeof("brainy")];
char stringpool_str8942[sizeof("fairly")];
char stringpool_str8949[sizeof("dependably")];
char stringpool_str8954[sizeof("temptingly")];
char stringpool_str8956[sizeof("beckon")];
char stringpool_str8958[sizeof("idyllic")];
char stringpool_str8963[sizeof("pleasurable")];
char stringpool_str8965[sizeof("staunchly")];
char stringpool_str8967[sizeof("beckons")];
char stringpool_str8969[sizeof("obtainable")];
char stringpool_str8983[sizeof("beckoned")];
char stringpool_str8992[sizeof("nicely")];
char stringpool_str9006[sizeof("valor")];
char stringpool_str9014[sizeof("frolic")];
char stringpool_str9043[sizeof("prize")];
char stringpool_str9057[sizeof("apotheosis")];
char stringpool_str9070[sizeof("poignant")];
char stringpool_str9074[sizeof("dignity")];
char stringpool_str9079[sizeof("dignify")];
char stringpool_str9094[sizeof("perfect")];
char stringpool_str9099[sizeof("knowledgeable")];
char stringpool_str9105[sizeof("swankiest")];
char stringpool_str9114[sizeof("ideally")];
char stringpool_str9116[sizeof("audibly")];
char stringpool_str9125[sizeof("advocates")];
char stringpool_str9126[sizeof("loveliness")];
char stringpool_str9127[sizeof("resourceful")];
char stringpool_str9129[sizeof("advocate")];
char stringpool_str9139[sizeof("protect")];
char stringpool_str9142[sizeof("perfection")];
char stringpool_str9145[sizeof("advocated")];
char stringpool_str9148[sizeof("impassioned")];
char stringpool_str9149[sizeof("swankier")];
char stringpool_str9159[sizeof("fancy")];
char stringpool_str9162[sizeof("clever")];
char stringpool_str9180[sizeof("praising")];
char stringpool_str9185[sizeof("legendary")];
char stringpool_str9187[sizeof("protection")];
char stringpool_str9189[sizeof("luminous")];
char stringpool_str9193[sizeof("low-risk")];
char stringpool_str9195[sizeof("splendor")];
char stringpool_str9212[sizeof("peace")];
char stringpool_str9214[sizeof("opulent")];
char stringpool_str9224[sizeof("reasonably")];
char stringpool_str9253[sizeof("inspiration")];
char stringpool_str9268[sizeof("instantly")];
char stringpool_str9288[sizeof("vibrant")];
char stringpool_str9300[sizeof("unlimited")];
char stringpool_str9301[sizeof("decency")];
char stringpool_str9306[sizeof("affably")];
char stringpool_str9336[sizeof("heroically")];
char stringpool_str9344[sizeof("truthful")];
char stringpool_str9366[sizeof("respectfully")];
char stringpool_str9371[sizeof("accomplishments")];
char stringpool_str9372[sizeof("flashy")];
char stringpool_str9378[sizeof("accomplished")];
char stringpool_str9384[sizeof("rectify")];
char stringpool_str9385[sizeof("ambitiously")];
char stringpool_str9392[sizeof("passion")];
char stringpool_str9395[sizeof("accomplishment")];
char stringpool_str9410[sizeof("passionate")];
char stringpool_str9416[sizeof("revel")];
char stringpool_str9417[sizeof("infallibility")];
char stringpool_str9428[sizeof("marvels")];
char stringpool_str9438[sizeof("accurately")];
char stringpool_str9444[sizeof("marveled")];
char stringpool_str9452[sizeof("magnificently")];
char stringpool_str9464[sizeof("proactive")];
char stringpool_str9467[sizeof("usable")];
char stringpool_str9481[sizeof("equitable")];
char stringpool_str9506[sizeof("self-sufficient")];
char stringpool_str9537[sizeof("patriot")];
char stringpool_str9544[sizeof("unbiased")];
char stringpool_str9593[sizeof("promises")];
char stringpool_str9594[sizeof("striving")];
char stringpool_str9597[sizeof("promise")];
char stringpool_str9603[sizeof("promised")];
char stringpool_str9612[sizeof("premier")];
char stringpool_str9622[sizeof("user-replaceable")];
char stringpool_str9641[sizeof("sufficiently")];
char stringpool_str9646[sizeof("resounding")];
char stringpool_str9651[sizeof("agilely")];
char stringpool_str9654[sizeof("loyalty")];
char stringpool_str9659[sizeof("prominent")];
char stringpool_str9692[sizeof("fine-looking")];
char stringpool_str9709[sizeof("accommodative")];
char stringpool_str9714[sizeof("unforgettable")];
char stringpool_str9723[sizeof("recover")];
char stringpool_str9725[sizeof("swank")];
char stringpool_str9736[sizeof("pre-eminent")];
char stringpool_str9743[sizeof("elevate")];
char stringpool_str9755[sizeof("elegantly")];
char stringpool_str9773[sizeof("fortune")];
char stringpool_str9780[sizeof("affluence")];
char stringpool_str9788[sizeof("fervent")];
char stringpool_str9794[sizeof("affluent")];
char stringpool_str9796[sizeof("advantages")];
char stringpool_str9798[sizeof("advantageous")];
char stringpool_str9800[sizeof("advantage")];
char stringpool_str9813[sizeof("valiant")];
char stringpool_str9824[sizeof("rejuvenate")];
char stringpool_str9830[sizeof("rejuvenated")];
char stringpool_str9854[sizeof("decisive")];
char stringpool_str9860[sizeof("unabashed")];
char stringpool_str9868[sizeof("decisiveness")];
char stringpool_str9883[sizeof("large-capacity")];
char stringpool_str9890[sizeof("fave")];
char stringpool_str9905[sizeof("marvelled")];
char stringpool_str9909[sizeof("renewed")];
char stringpool_str9943[sizeof("outperforms")];
char stringpool_str9945[sizeof("won")];
char stringpool_str9954[sizeof("outperformed")];
char stringpool_str9956[sizeof("marvellous")];
char stringpool_str9958[sizeof("favored")];
char stringpool_str9961[sizeof("unaffected")];
char stringpool_str9968[sizeof("renown")];
char stringpool_str9970[sizeof("pleasing")];
char stringpool_str9984[sizeof("optimal")];
char stringpool_str9991[sizeof("fortuitous")];
char stringpool_str9995[sizeof("renowned")];
char stringpool_str9996[sizeof("wise")];
char stringpool_str10000[sizeof("admirably")];
char stringpool_str10001[sizeof("wins")];
char stringpool_str10002[sizeof("simplify")];
char stringpool_str10015[sizeof("win")];
char stringpool_str10016[sizeof("spellbinding")];
char stringpool_str10019[sizeof("enviable")];
char stringpool_str10025[sizeof("woo")];
char stringpool_str10031[sizeof("favor")];
char stringpool_str10059[sizeof("ecenomical")];
char stringpool_str10065[sizeof("effectual")];
char stringpool_str10074[sizeof("dummy-proof")];
char stringpool_str10084[sizeof("colorful")];
char stringpool_str10094[sizeof("wonders")];
char stringpool_str10109[sizeof("economical")];
char stringpool_str10113[sizeof("savings")];
char stringpool_str10126[sizeof("priceless")];
char stringpool_str10139[sizeof("favorite")];
char stringpool_str10147[sizeof("benevolence")];
char stringpool_str10148[sizeof("unrestricted")];
char stringpool_str10154[sizeof("fascinatingly")];
char stringpool_str10155[sizeof("favorited")];
char stringpool_str10163[sizeof("wonder")];
char stringpool_str10166[sizeof("benevolent")];
char stringpool_str10169[sizeof("winners")];
char stringpool_str10187[sizeof("harmony")];
char stringpool_str10200[sizeof("pinnacle")];
char stringpool_str10203[sizeof("jollify")];
char stringpool_str10205[sizeof("veritable")];
char stringpool_str10208[sizeof("faithfulness")];
char stringpool_str10210[sizeof("convenience")];
char stringpool_str10213[sizeof("convience")];
char stringpool_str10219[sizeof("innovation")];
char stringpool_str10222[sizeof("amicability")];
char stringpool_str10227[sizeof("convient")];
char stringpool_str10229[sizeof("convenient")];
char stringpool_str10235[sizeof("convienient")];
char stringpool_str10238[sizeof("winner")];
char stringpool_str10245[sizeof("inspirational")];
char stringpool_str10252[sizeof("orderly")];
char stringpool_str10262[sizeof("spellbound")];
char stringpool_str10266[sizeof("permissible")];
char stringpool_str10273[sizeof("cohere")];
char stringpool_str10275[sizeof("vigilance")];
char stringpool_str10288[sizeof("individualized")];
char stringpool_str10289[sizeof("vigilant")];
char stringpool_str10294[sizeof("infallibly")];
char stringpool_str10307[sizeof("cheer")];
char stringpool_str10311[sizeof("stimulates")];
char stringpool_str10313[sizeof("multi-purpose")];
char stringpool_str10315[sizeof("stimulate")];
char stringpool_str10318[sizeof("speedy")];
char stringpool_str10319[sizeof("godsend")];
char stringpool_str10321[sizeof("good")];
char stringpool_str10335[sizeof("diversified")];
char stringpool_str10336[sizeof("coherence")];
char stringpool_str10347[sizeof("worthiness")];
char stringpool_str10350[sizeof("coherent")];
char stringpool_str10372[sizeof("goood")];
char stringpool_str10386[sizeof("astounding")];
char stringpool_str10390[sizeof("palatial")];
char stringpool_str10392[sizeof("shine")];
char stringpool_str10398[sizeof("outstrip")];
char stringpool_str10400[sizeof("goodness")];
char stringpool_str10404[sizeof("harmoniously")];
char stringpool_str10407[sizeof("marvel")];
char stringpool_str10414[sizeof("impeccable")];
char stringpool_str10417[sizeof("famous")];
char stringpool_str10422[sizeof("outperform")];
char stringpool_str10423[sizeof("gifted")];
char stringpool_str10431[sizeof("brave")];
char stringpool_str10437[sizeof("stimulative")];
char stringpool_str10441[sizeof("grin")];
char stringpool_str10470[sizeof("fortunate")];
char stringpool_str10479[sizeof("refresh")];
char stringpool_str10487[sizeof("optimistic")];
char stringpool_str10495[sizeof("energize")];
char stringpool_str10499[sizeof("capability")];
char stringpool_str10513[sizeof("versatile")];
char stringpool_str10515[sizeof("god-send")];
char stringpool_str10523[sizeof("sporty")];
char stringpool_str10527[sizeof("enrichment")];
char stringpool_str10529[sizeof("applaud")];
char stringpool_str10545[sizeof("vouchsafe")];
char stringpool_str10559[sizeof("thinner")];
char stringpool_str10581[sizeof("conciliatory")];
char stringpool_str10618[sizeof("chaste")];
char stringpool_str10623[sizeof("trophy")];
char stringpool_str10624[sizeof("incredibly")];
char stringpool_str10642[sizeof("spectacularly")];
char stringpool_str10644[sizeof("happiness")];
char stringpool_str10647[sizeof("everlasting")];
char stringpool_str10648[sizeof("beloved")];
char stringpool_str10652[sizeof("grand")];
char stringpool_str10676[sizeof("gems")];
char stringpool_str10681[sizeof("gain")];
char stringpool_str10692[sizeof("gains")];
char stringpool_str10697[sizeof("happier")];
char stringpool_str10718[sizeof("gained")];
char stringpool_str10722[sizeof("great")];
char stringpool_str10728[sizeof("gentle")];
char stringpool_str10733[sizeof("prettily")];
char stringpool_str10746[sizeof("greatness")];
char stringpool_str10755[sizeof("greatest")];
char stringpool_str10758[sizeof("sincerity")];
char stringpool_str10767[sizeof("unreal")];
char stringpool_str10775[sizeof("gentlest")];
char stringpool_str10779[sizeof("agility")];
char stringpool_str10790[sizeof("punctual")];
char stringpool_str10792[sizeof("peps")];
char stringpool_str10821[sizeof("exonerate")];
char stringpool_str10854[sizeof("valuable")];
char stringpool_str10866[sizeof("works")];
char stringpool_str10868[sizeof("irreplaceable")];
char stringpool_str10892[sizeof("worked")];
char stringpool_str10895[sizeof("encourage")];
char stringpool_str10902[sizeof("dumbfounded")];
char stringpool_str10910[sizeof("smoothes")];
char stringpool_str10919[sizeof("encouragement")];
char stringpool_str10942[sizeof("revitalize")];
char stringpool_str10944[sizeof("fruitful")];
char stringpool_str10950[sizeof("best-known")];
char stringpool_str10961[sizeof("smoothest")];
char stringpool_str10968[sizeof("mind-blowing")];
char stringpool_str10978[sizeof("heartwarming")];
char stringpool_str10993[sizeof("warmer")];
char stringpool_str10994[sizeof("flawless")];
char stringpool_str11005[sizeof("smoother")];
char stringpool_str11011[sizeof("supremely")];
char stringpool_str11015[sizeof("unmatched")];
char stringpool_str11016[sizeof("invulnerable")];
char stringpool_str11018[sizeof("crisp")];
char stringpool_str11024[sizeof("receptive")];
char stringpool_str11053[sizeof("ingenuously")];
char stringpool_str11062[sizeof("exult")];
char stringpool_str11097[sizeof("enthralled")];
char stringpool_str11106[sizeof("profound")];
char stringpool_str11108[sizeof("ingeniously")];
char stringpool_str11112[sizeof("precise")];
char stringpool_str11116[sizeof("unassailable")];
char stringpool_str11127[sizeof("charm")];
char stringpool_str11129[sizeof("advanced")];
char stringpool_str11131[sizeof("impartial")];
char stringpool_str11140[sizeof("agreeably")];
char stringpool_str11141[sizeof("unbeatable")];
char stringpool_str11150[sizeof("guidance")];
char stringpool_str11155[sizeof("gem")];
char stringpool_str11159[sizeof("proper")];
char stringpool_str11187[sizeof("auspicious")];
char stringpool_str11194[sizeof("faithful")];
char stringpool_str11198[sizeof("homage")];
char stringpool_str11200[sizeof("astonish")];
char stringpool_str11209[sizeof("fabulous")];
char stringpool_str11211[sizeof("glee")];
char stringpool_str11226[sizeof("verifiable")];
char stringpool_str11230[sizeof("youthful")];
char stringpool_str11251[sizeof("warm")];
char stringpool_str11259[sizeof("pardon")];
char stringpool_str11271[sizeof("gold")];
char stringpool_str11323[sizeof("golden")];
char stringpool_str11324[sizeof("exalted")];
char stringpool_str11327[sizeof("exalt")];
char stringpool_str11340[sizeof("amply")];
char stringpool_str11341[sizeof("luxuriate")];
char stringpool_str11348[sizeof("useable")];
char stringpool_str11381[sizeof("luxuriant")];
char stringpool_str11387[sizeof("splendidly")];
char stringpool_str11423[sizeof("skillful")];
char stringpool_str11446[sizeof("rejuvenating")];
char stringpool_str11453[sizeof("appeal")];
char stringpool_str11455[sizeof("exultant")];
char stringpool_str11457[sizeof("extol")];
char stringpool_str11469[sizeof("glisten")];
char stringpool_str11470[sizeof("exellent")];
char stringpool_str11491[sizeof("superiority")];
char stringpool_str11503[sizeof("trump")];
char stringpool_str11510[sizeof("eulogize")];
char stringpool_str11511[sizeof("guarantee")];
char stringpool_str11517[sizeof("exultation")];
char stringpool_str11519[sizeof("glitter")];
char stringpool_str11526[sizeof("diligence")];
char stringpool_str11531[sizeof("spellbindingly")];
char stringpool_str11540[sizeof("diligent")];
char stringpool_str11551[sizeof("glad")];
char stringpool_str11570[sizeof("outperforming")];
char stringpool_str11571[sizeof("promoter")];
char stringpool_str11581[sizeof("exuberant")];
char stringpool_str11598[sizeof("galore")];
char stringpool_str11601[sizeof("peaceable")];
char stringpool_str11624[sizeof("gladden")];
char stringpool_str11630[sizeof("gladness")];
char stringpool_str11631[sizeof("attractive")];
char stringpool_str11633[sizeof("personages")];
char stringpool_str11641[sizeof("panoramic")];
char stringpool_str11651[sizeof("plentiful")];
char stringpool_str11657[sizeof("user-friendly")];
char stringpool_str11660[sizeof("prominence")];
char stringpool_str11661[sizeof("jovial")];
char stringpool_str11663[sizeof("warmhearted")];
char stringpool_str11669[sizeof("work")];
char stringpool_str11673[sizeof("electrify")];
char stringpool_str11701[sizeof("supremacy")];
char stringpool_str11751[sizeof("festive")];
char stringpool_str11755[sizeof("pampers")];
char stringpool_str11765[sizeof("personalized")];
char stringpool_str11771[sizeof("pampered")];
char stringpool_str11778[sizeof("rejoicing")];
char stringpool_str11780[sizeof("pamperedness")];
char stringpool_str11782[sizeof("exaltation")];
char stringpool_str11802[sizeof("revolutionary")];
char stringpool_str11805[sizeof("fervid")];
char stringpool_str11809[sizeof("convincing")];
char stringpool_str11824[sizeof("pamper")];
char stringpool_str11825[sizeof("popular")];
char stringpool_str11852[sizeof("trustworthiness")];
char stringpool_str11856[sizeof("sumptuously")];
char stringpool_str11857[sizeof("divinely")];
char stringpool_str11858[sizeof("sparkling")];
char stringpool_str11878[sizeof("lovable")];
char stringpool_str11887[sizeof("loving")];
char stringpool_str11892[sizeof("believeable")];
char stringpool_str11898[sizeof("fortitude")];
char stringpool_str11901[sizeof("astoundingly")];
char stringpool_str11906[sizeof("responsibly")];
char stringpool_str11915[sizeof("preferably")];
char stringpool_str11919[sizeof("glimmer")];
char stringpool_str11925[sizeof("painlessly")];
char stringpool_str11939[sizeof("non-violence")];
char stringpool_str11945[sizeof("winnable")];
char stringpool_str11958[sizeof("non-violent")];
char stringpool_str11974[sizeof("effusively")];
char stringpool_str11975[sizeof("available")];
char stringpool_str11988[sizeof("originality")];
char stringpool_str11993[sizeof("exceed")];
char stringpool_str11994[sizeof("thrills")];
char stringpool_str11997[sizeof("civility")];
char stringpool_str11999[sizeof("joyous")];
char stringpool_str12009[sizeof("exceeds")];
char stringpool_str12010[sizeof("thrilled")];
char stringpool_str12025[sizeof("exceeded")];
char stringpool_str12037[sizeof("right")];
char stringpool_str12042[sizeof("fresh")];
char stringpool_str12052[sizeof("heavenly")];
char stringpool_str12057[sizeof("stimulating")];
char stringpool_str12061[sizeof("rightness")];
char stringpool_str12069[sizeof("togetherness")];
char stringpool_str12081[sizeof("piety")];
char stringpool_str12084[sizeof("enthral")];
char stringpool_str12085[sizeof("enthrall")];
char stringpool_str12089[sizeof("righten")];
char stringpool_str12091[sizeof("altruistic")];
char stringpool_str12096[sizeof("pleasurably")];
char stringpool_str12114[sizeof("deservedly")];
char stringpool_str12137[sizeof("tough")];
char stringpool_str12139[sizeof("reverently")];
char stringpool_str12143[sizeof("excite")];
char stringpool_str12153[sizeof("excitedness")];
char stringpool_str12154[sizeof("excited")];
char stringpool_str12158[sizeof("thrift")];
char stringpool_str12159[sizeof("blissful")];
char stringpool_str12164[sizeof("excites")];
char stringpool_str12165[sizeof("overture")];
char stringpool_str12176[sizeof("foresight")];
char stringpool_str12197[sizeof("excitement")];
char stringpool_str12204[sizeof("ethical")];
char stringpool_str12256[sizeof("supports")];
char stringpool_str12277[sizeof("supported")];
char stringpool_str12280[sizeof("support")];
char stringpool_str12305[sizeof("influential")];
char stringpool_str12307[sizeof("detachable")];
char stringpool_str12311[sizeof("inventive")];
char stringpool_str12330[sizeof("favorable")];
char stringpool_str12331[sizeof("ingenuity")];
char stringpool_str12409[sizeof("rapture")];
char stringpool_str12423[sizeof("excels")];
char stringpool_str12427[sizeof("faith")];
char stringpool_str12444[sizeof("exceled")];
char stringpool_str12446[sizeof("thank")];
char stringpool_str12447[sizeof("supporter")];
char stringpool_str12450[sizeof("richness")];
char stringpool_str12455[sizeof("charming")];
char stringpool_str12463[sizeof("extoll")];
char stringpool_str12472[sizeof("genuine")];
char stringpool_str12477[sizeof("raptureous")];
char stringpool_str12480[sizeof("well-received")];
char stringpool_str12484[sizeof("truthfully")];
char stringpool_str12487[sizeof("shimmering")];
char stringpool_str12490[sizeof("pleasingly")];
char stringpool_str12501[sizeof("guiltless")];
char stringpool_str12507[sizeof("diplomatic")];
char stringpool_str12510[sizeof("excelent")];
char stringpool_str12518[sizeof("dumbfounding")];
char stringpool_str12520[sizeof("rapport")];
char stringpool_str12538[sizeof("well-intentioned")];
char stringpool_str12545[sizeof("passionately")];
char stringpool_str12583[sizeof("richer")];
char stringpool_str12585[sizeof("well-informed")];
char stringpool_str12589[sizeof("cherished")];
char stringpool_str12593[sizeof("savior")];
char stringpool_str12594[sizeof("lighter")];
char stringpool_str12620[sizeof("self-sufficiency")];
char stringpool_str12632[sizeof("manageable")];
char stringpool_str12637[sizeof("encouraging")];
char stringpool_str12643[sizeof("distinguished")];
char stringpool_str12671[sizeof("stability")];
char stringpool_str12687[sizeof("cleverly")];
char stringpool_str12694[sizeof("invaluable")];
char stringpool_str12700[sizeof("pleasantly")];
char stringpool_str12702[sizeof("grace")];
char stringpool_str12705[sizeof("enhances")];
char stringpool_str12709[sizeof("enhance")];
char stringpool_str12715[sizeof("enhanced")];
char stringpool_str12718[sizeof("well-established")];
char stringpool_str12732[sizeof("nourish")];
char stringpool_str12738[sizeof("enhancement")];
char stringpool_str12741[sizeof("stylishly")];
char stringpool_str12746[sizeof("humourous")];
char stringpool_str12754[sizeof("awesome")];
char stringpool_str12758[sizeof("awesomeness")];
char stringpool_str12767[sizeof("recovery")];
char stringpool_str12769[sizeof("workable")];
char stringpool_str12780[sizeof("adaptive")];
char stringpool_str12810[sizeof("well-regarded")];
char stringpool_str12831[sizeof("adulatory")];
char stringpool_str12854[sizeof("humorously")];
char stringpool_str12866[sizeof("believable")];
char stringpool_str12867[sizeof("capably")];
char stringpool_str12874[sizeof("staunch")];
char stringpool_str12881[sizeof("well")];
char stringpool_str12897[sizeof("better-than-expected")];
char stringpool_str12899[sizeof("enjoyably")];
char stringpool_str12928[sizeof("prodigious")];
char stringpool_str12931[sizeof("cashbacks")];
char stringpool_str12938[sizeof("advantageously")];
char stringpool_str12948[sizeof("evocative")];
char stringpool_str12973[sizeof("thrill")];
char stringpool_str12990[sizeof("unabashedly")];
char stringpool_str13056[sizeof("appreciates")];
char stringpool_str13060[sizeof("appreciate")];
char stringpool_str13062[sizeof("appreciative")];
char stringpool_str13066[sizeof("appreciated")];
char stringpool_str13068[sizeof("genial")];
char stringpool_str13076[sizeof("well-bred")];
char stringpool_str13097[sizeof("glistening")];
char stringpool_str13100[sizeof("flourish")];
char stringpool_str13104[sizeof("unparalleled")];
char stringpool_str13106[sizeof("poetic")];
char stringpool_str13110[sizeof("exalting")];
char stringpool_str13111[sizeof("enchanted")];
char stringpool_str13114[sizeof("enchant")];
char stringpool_str13123[sizeof("charisma")];
char stringpool_str13130[sizeof("light-hearted")];
char stringpool_str13131[sizeof("fortuitously")];
char stringpool_str13152[sizeof("enviably")];
char stringpool_str13188[sizeof("altruistically")];
char stringpool_str13210[sizeof("integrated")];
char stringpool_str13212[sizeof("poeticize")];
char stringpool_str13213[sizeof("fast-growing")];
char stringpool_str13220[sizeof("unity")];
char stringpool_str13231[sizeof("breathlessness")];
char stringpool_str13257[sizeof("merciful")];
char stringpool_str13258[sizeof("rewarding")];
char stringpool_str13262[sizeof("variety")];
char stringpool_str13264[sizeof("pretty")];
char stringpool_str13266[sizeof("impartially")];
char stringpool_str13267[sizeof("impartiality")];
char stringpool_str13271[sizeof("geekier")];
char stringpool_str13281[sizeof("zippy")];
char stringpool_str13293[sizeof("rejoicingly")];
char stringpool_str13294[sizeof("world-famous")];
char stringpool_str13324[sizeof("convincingly")];
char stringpool_str13328[sizeof("deserving")];
char stringpool_str13338[sizeof("proficient")];
char stringpool_str13344[sizeof("conveniently")];
char stringpool_str13347[sizeof("continuity")];
char stringpool_str13362[sizeof("prudently")];
char stringpool_str13368[sizeof("glitz")];
char stringpool_str13369[sizeof("gallant")];
char stringpool_str13377[sizeof("unconditional")];
char stringpool_str13401[sizeof("marvelous")];
char stringpool_str13405[sizeof("marvelousness")];
char stringpool_str13413[sizeof("upbeat")];
char stringpool_str13427[sizeof("excel")];
char stringpool_str13431[sizeof("overtakes")];
char stringpool_str13434[sizeof("well-behaved")];
char stringpool_str13435[sizeof("overtake")];
char stringpool_str13460[sizeof("windfall")];
char stringpool_str13461[sizeof("overtaken")];
char stringpool_str13465[sizeof("generosity")];
char stringpool_str13467[sizeof("glimmering")];
char stringpool_str13470[sizeof("excelled")];
char stringpool_str13511[sizeof("excellent")];
char stringpool_str13546[sizeof("well-made")];
char stringpool_str13547[sizeof("impeccably")];
char stringpool_str13565[sizeof("well-mannered")];
char stringpool_str13582[sizeof("exuberance")];
char stringpool_str13591[sizeof("happy")];
char stringpool_str13604[sizeof("patriotic")];
char stringpool_str13605[sizeof("fortunately")];
char stringpool_str13653[sizeof("nurturing")];
char stringpool_str13661[sizeof("compactly")];
char stringpool_str13672[sizeof("patiently")];
char stringpool_str13677[sizeof("novelty")];
char stringpool_str13687[sizeof("foolproof")];
char stringpool_str13706[sizeof("wonderful")];
char stringpool_str13756[sizeof("appreciable")];
char stringpool_str13759[sizeof("cashback")];
char stringpool_str13762[sizeof("sweetly")];
char stringpool_str13768[sizeof("versatility")];
char stringpool_str13779[sizeof("inspiring")];
char stringpool_str13795[sizeof("meaningful")];
char stringpool_str13796[sizeof("outwit")];
char stringpool_str13809[sizeof("prosperous")];
char stringpool_str13825[sizeof("law-abiding")];
char stringpool_str13831[sizeof("prosper")];
char stringpool_str13833[sizeof("fervor")];
char stringpool_str13841[sizeof("excallent")];
char stringpool_str13849[sizeof("gainful")];
char stringpool_str13884[sizeof("well-managed")];
char stringpool_str13889[sizeof("breakthrough")];
char stringpool_str13898[sizeof("supporting")];
char stringpool_str13940[sizeof("exciting")];
char stringpool_str13965[sizeof("intrigue")];
char stringpool_str13969[sizeof("principled")];
char stringpool_str13984[sizeof("joyful")];
char stringpool_str13996[sizeof("energy-efficient")];
char stringpool_str14002[sizeof("shimmeringly")];
char stringpool_str14005[sizeof("engaging")];
char stringpool_str14022[sizeof("dexterous")];
char stringpool_str14025[sizeof("hallowed")];
char stringpool_str14037[sizeof("famously")];
char stringpool_str14058[sizeof("extraordinary")];
char stringpool_str14060[sizeof("extraordinarily")];
char stringpool_str14063[sizeof("ultra-crisp")];
char stringpool_str14067[sizeof("wonderous")];
char stringpool_str14069[sizeof("peacekeepers")];
char stringpool_str14125[sizeof("well-balanced")];
char stringpool_str14152[sizeof("encouragingly")];
char stringpool_str14161[sizeof("groundbreaking")];
char stringpool_str14198[sizeof("integral")];
char stringpool_str14201[sizeof("excellant")];
char stringpool_str14241[sizeof("envy")];
char stringpool_str14260[sizeof("prompt")];
char stringpool_str14266[sizeof("godlike")];
char stringpool_str14301[sizeof("prolific")];
char stringpool_str14332[sizeof("beckoning")];
char stringpool_str14334[sizeof("faithfully")];
char stringpool_str14338[sizeof("gusto")];
char stringpool_str14374[sizeof("gooood")];
char stringpool_str14389[sizeof("gleeful")];
char stringpool_str14405[sizeof("well-educated")];
char stringpool_str14410[sizeof("upgraded")];
char stringpool_str14416[sizeof("chic")];
char stringpool_str14447[sizeof("bravo")];
char stringpool_str14452[sizeof("playful")];
char stringpool_str14464[sizeof("empowerment")];
char stringpool_str14498[sizeof("smoothly")];
char stringpool_str14506[sizeof("energetic")];
char stringpool_str14510[sizeof("prowess")];
char stringpool_str14522[sizeof("suavely")];
char stringpool_str14525[sizeof("empower")];
char stringpool_str14530[sizeof("charitable")];
char stringpool_str14542[sizeof("ovation")];
char stringpool_str14563[sizeof("skillfully")];
char stringpool_str14607[sizeof("luxurious")];
char stringpool_str14633[sizeof("well-backlit")];
char stringpool_str14658[sizeof("imaculate")];
char stringpool_str14682[sizeof("positives")];
char stringpool_str14684[sizeof("properly")];
char stringpool_str14686[sizeof("positive")];
char stringpool_str14690[sizeof("triumph")];
char stringpool_str14692[sizeof("jaw-droping")];
char stringpool_str14694[sizeof("impressiveness")];
char stringpool_str14695[sizeof("impressive")];
char stringpool_str14696[sizeof("exuberantly")];
char stringpool_str14723[sizeof("uplift")];
char stringpool_str14727[sizeof("well-being")];
char stringpool_str14728[sizeof("evenly")];
char stringpool_str14732[sizeof("enchanting")];
char stringpool_str14757[sizeof("upliftment")];
char stringpool_str14766[sizeof("attractively")];
char stringpool_str14773[sizeof("rewardingly")];
char stringpool_str14774[sizeof("openly")];
char stringpool_str14787[sizeof("pep")];
char stringpool_str14802[sizeof("leading")];
char stringpool_str14840[sizeof("pepped")];
char stringpool_str14852[sizeof("adoring")];
char stringpool_str14861[sizeof("charismatic")];
char stringpool_str14872[sizeof("twinkly")];
char stringpool_str14878[sizeof("levity")];
char stringpool_str14882[sizeof("persevere")];
char stringpool_str14889[sizeof("proves")];
char stringpool_str14919[sizeof("proven")];
char stringpool_str14921[sizeof("overjoyed")];
char stringpool_str14922[sizeof("blockbuster")];
char stringpool_str14925[sizeof("profuse")];
char stringpool_str14952[sizeof("promising")];
char stringpool_str14954[sizeof("wisdom")];
char stringpool_str14957[sizeof("gratifies")];
char stringpool_str14962[sizeof("unquestionable")];
char stringpool_str14975[sizeof("charmingly")];
char stringpool_str14977[sizeof("gratified")];
char stringpool_str14984[sizeof("purify")];
char stringpool_str14986[sizeof("trustworthy")];
char stringpool_str14993[sizeof("hard-working")];
char stringpool_str15072[sizeof("overtaking")];
char stringpool_str15128[sizeof("upgradeable")];
char stringpool_str15131[sizeof("fashionable")];
char stringpool_str15139[sizeof("flawlessly")];
char stringpool_str15145[sizeof("lower-priced")];
char stringpool_str15159[sizeof("captivate")];
char stringpool_str15171[sizeof("witty")];
char stringpool_str15173[sizeof("swanky")];
char stringpool_str15215[sizeof("perseverance")];
char stringpool_str15216[sizeof("authentic")];
char stringpool_str15218[sizeof("lovely")];
char stringpool_str15222[sizeof("enrapture")];
char stringpool_str15228[sizeof("enraptured")];
char stringpool_str15241[sizeof("profoundly")];
char stringpool_str15242[sizeof("amusing")];
char stringpool_str15273[sizeof("breathtaking")];
char stringpool_str15275[sizeof("irreproachable")];
char stringpool_str15288[sizeof("lively")];
char stringpool_str15299[sizeof("blissfully")];
char stringpool_str15311[sizeof("gratification")];
char stringpool_str15314[sizeof("propitious")];
char stringpool_str15347[sizeof("perfectly")];
char stringpool_str15354[sizeof("fabulously")];
char stringpool_str15365[sizeof("exultingly")];
char stringpool_str15371[sizeof("healthful")];
char stringpool_str15395[sizeof("time-honored")];
char stringpool_str15406[sizeof("cushy")];
char stringpool_str15412[sizeof("darling")];
char stringpool_str15415[sizeof("fervidly")];
char stringpool_str15421[sizeof("gutsy")];
char stringpool_str15452[sizeof("invincible")];
char stringpool_str15491[sizeof("shiny")];
char stringpool_str15512[sizeof("excellence")];
char stringpool_str15533[sizeof("avidly")];
char stringpool_str15541[sizeof("vibrantly")];
char stringpool_str15572[sizeof("eye-catching")];
char stringpool_str15573[sizeof("revive")];
char stringpool_str15594[sizeof("revives")];
char stringpool_str15597[sizeof("paramount")];
char stringpool_str15602[sizeof("intriguing")];
char stringpool_str15607[sizeof("smiling")];
char stringpool_str15617[sizeof("raptureously")];
char stringpool_str15619[sizeof("joyously")];
char stringpool_str15630[sizeof("exaltingly")];
char stringpool_str15657[sizeof("bravery")];
char stringpool_str15660[sizeof("diligently")];
char stringpool_str15688[sizeof("virtue")];
char stringpool_str15697[sizeof("vivid")];
char stringpool_str15724[sizeof("upscale")];
char stringpool_str15773[sizeof("mightily")];
char stringpool_str15802[sizeof("calming")];
char stringpool_str15808[sizeof("headway")];
char stringpool_str15829[sizeof("invaluablely")];
char stringpool_str15839[sizeof("appealing")];
char stringpool_str15841[sizeof("wonderfully")];
char stringpool_str15843[sizeof("flexible")];
char stringpool_str15851[sizeof("prodigy")];
char stringpool_str15856[sizeof("adequate")];
char stringpool_str15872[sizeof("eloquence")];
char stringpool_str15886[sizeof("eloquent")];
char stringpool_str15898[sizeof("energy-saving")];
char stringpool_str15906[sizeof("pamperedly")];
char stringpool_str15934[sizeof("inviolate")];
char stringpool_str15953[sizeof("devout")];
char stringpool_str15968[sizeof("responsive")];
char stringpool_str16015[sizeof("victorious")];
char stringpool_str16017[sizeof("righteous")];
char stringpool_str16021[sizeof("righteousness")];
char stringpool_str16041[sizeof("fervently")];
char stringpool_str16059[sizeof("purposeful")];
char stringpool_str16066[sizeof("valiantly")];
char stringpool_str16068[sizeof("prodigiously")];
char stringpool_str16102[sizeof("upgradable")];
char stringpool_str16146[sizeof("sweeping")];
char stringpool_str16165[sizeof("geeky")];
char stringpool_str16167[sizeof("sexy")];
char stringpool_str16168[sizeof("eyecatch")];
char stringpool_str16197[sizeof("appreciatively")];
char stringpool_str16247[sizeof("enchantingly")];
char stringpool_str16306[sizeof("undaunted")];
char stringpool_str16339[sizeof("spiritual")];
char stringpool_str16372[sizeof("rapturous")];
char stringpool_str16382[sizeof("beutifully")];
char stringpool_str16397[sizeof("mercifully")];
char stringpool_str16430[sizeof("expansive")];
char stringpool_str16439[sizeof("worthy")];
char stringpool_str16453[sizeof("proficiently")];
char stringpool_str16455[sizeof("well-rounded")];
char stringpool_str16456[sizeof("gratifying")];
char stringpool_str16460[sizeof("excitingly")];
char stringpool_str16481[sizeof("glory")];
char stringpool_str16489[sizeof("cheery")];
char stringpool_str16506[sizeof("unrivaled")];
char stringpool_str16518[sizeof("spacious")];
char stringpool_str16541[sizeof("marvelously")];
char stringpool_str16582[sizeof("bullish")];
char stringpool_str16584[sizeof("maneuverable")];
char stringpool_str16590[sizeof("uncomplicated")];
char stringpool_str16599[sizeof("joyfully")];
char stringpool_str16607[sizeof("booming")];
char stringpool_str16626[sizeof("excellently")];
char stringpool_str16650[sizeof("stylish")];
char stringpool_str16659[sizeof("unbound")];
char stringpool_str16670[sizeof("adventuresome")];
char stringpool_str16675[sizeof("ftw")];
char stringpool_str16713[sizeof("adventurous")];
char stringpool_str16736[sizeof("happily")];
char stringpool_str16749[sizeof("wisely")];
char stringpool_str16759[sizeof("luxury")];
char stringpool_str16788[sizeof("breathtakingly")];
char stringpool_str16791[sizeof("gaily")];
char stringpool_str16868[sizeof("healthy")];
char stringpool_str16901[sizeof("captivating")];
char stringpool_str16902[sizeof("prosperity")];
char stringpool_str16935[sizeof("inviolable")];
char stringpool_str16970[sizeof("overtook")];
char stringpool_str16977[sizeof("lovably")];
char stringpool_str16995[sizeof("eventful")];
char stringpool_str17004[sizeof("gaiety")];
char stringpool_str17038[sizeof("protective")];
char stringpool_str17060[sizeof("profusion")];
char stringpool_str17069[sizeof("goodly")];
char stringpool_str17085[sizeof("viewable")];
char stringpool_str17117[sizeof("intriguingly")];
char stringpool_str17150[sizeof("appropriate")];
char stringpool_str17162[sizeof("dexterously")];
char stringpool_str17207[sizeof("wonderously")];
char stringpool_str17245[sizeof("low-price")];
char stringpool_str17251[sizeof("low-priced")];
char stringpool_str17255[sizeof("empathize")];
char stringpool_str17268[sizeof("thrifty")];
char stringpool_str17279[sizeof("wieldy")];
char stringpool_str17282[sizeof("prestige")];
char stringpool_str17294[sizeof("expeditiously")];
char stringpool_str17335[sizeof("prestigious")];
char stringpool_str17359[sizeof("thrilling")];
char stringpool_str17374[sizeof("exceeding")];
char stringpool_str17384[sizeof("revival")];
char stringpool_str17385[sizeof("precisely")];
char stringpool_str17387[sizeof("cheapest")];
char stringpool_str17427[sizeof("wows")];
char stringpool_str17430[sizeof("welcome")];
char stringpool_str17431[sizeof("cheaper")];
char stringpool_str17440[sizeof("snappy")];
char stringpool_str17444[sizeof("trivially")];
char stringpool_str17448[sizeof("wowed")];
char stringpool_str17492[sizeof("sharpest")];
char stringpool_str17503[sizeof("amazing")];
char stringpool_str17529[sizeof("warmly")];
char stringpool_str17536[sizeof("sharper")];
char stringpool_str17539[sizeof("expertly")];
char stringpool_str17584[sizeof("authoritative")];
char stringpool_str17592[sizeof("exaltedly")];
char stringpool_str17708[sizeof("invincibility")];
char stringpool_str17741[sizeof("brand-new")];
char stringpool_str17747[sizeof("luxuriously")];
char stringpool_str17795[sizeof("fav")];
char stringpool_str17823[sizeof("prospros")];
char stringpool_str17830[sizeof("impressively")];
char stringpool_str17855[sizeof("promptly")];
char stringpool_str17871[sizeof("dextrous")];
char stringpool_str17883[sizeof("useful")];
char stringpool_str17916[sizeof("wondrous")];
char stringpool_str17931[sizeof("cohesive")];
char stringpool_str17951[sizeof("gratify")];
char stringpool_str17963[sizeof("sweetheart")];
char stringpool_str17971[sizeof("gratifyingly")];
char stringpool_str17984[sizeof("awestruck")];
char stringpool_str18004[sizeof("thrive")];
char stringpool_str18043[sizeof("favour")];
char stringpool_str18070[sizeof("innovative")];
char stringpool_str18095[sizeof("unquestionably")];
char stringpool_str18115[sizeof("privilege")];
char stringpool_str18121[sizeof("privileged")];
char stringpool_str18153[sizeof("rightly")];
char stringpool_str18161[sizeof("peaceful")];
char stringpool_str18179[sizeof("plush")];
char stringpool_str18191[sizeof("generous")];
char stringpool_str18215[sizeof("enthuse")];
char stringpool_str18232[sizeof("polished")];
char stringpool_str18254[sizeof("genius")];
char stringpool_str18264[sizeof("fashionably")];
char stringpool_str18288[sizeof("lawful")];
char stringpool_str18299[sizeof("gladly")];
char stringpool_str18304[sizeof("mighty")];
char stringpool_str18362[sizeof("topnotch")];
char stringpool_str18407[sizeof("well-connected")];
char stringpool_str18422[sizeof("excitedly")];
char stringpool_str18454[sizeof("propitiously")];
char stringpool_str18539[sizeof("sophisticated")];
char stringpool_str18564[sizeof("jaw-dropping")];
char stringpool_str18645[sizeof("excellency")];
char stringpool_str18651[sizeof("glorify")];
char stringpool_str18659[sizeof("improves")];
char stringpool_str18661[sizeof("grandeur")];
char stringpool_str18663[sizeof("improve")];
char stringpool_str18668[sizeof("improvements")];
char stringpool_str18669[sizeof("improved")];
char stringpool_str18692[sizeof("improvement")];
char stringpool_str18777[sizeof("visionary")];
char stringpool_str18813[sizeof("worthwhile")];
char stringpool_str18826[sizeof("positively")];
char stringpool_str18842[sizeof("undamaged")];
char stringpool_str18874[sizeof("thrillingly")];
char stringpool_str18889[sizeof("exceedingly")];
char stringpool_str18938[sizeof("victory")];
char stringpool_str18941[sizeof("leverage")];
char stringpool_str18947[sizeof("gumption")];
char stringpool_str18987[sizeof("exemplar")];
char stringpool_str19003[sizeof("inexpensive")];
char stringpool_str19027[sizeof("awesomely")];
char stringpool_str19049[sizeof("precious")];
char stringpool_str19091[sizeof("providence")];
char stringpool_str19103[sizeof("helping")];
char stringpool_str19119[sizeof("richly")];
char stringpool_str19122[sizeof("gainfully")];
char stringpool_str19142[sizeof("easygoing")];
char stringpool_str19157[sizeof("righteously")];
char stringpool_str19166[sizeof("cheerful")];
char stringpool_str19317[sizeof("examplar")];
char stringpool_str19319[sizeof("wellbeing")];
char stringpool_str19422[sizeof("high-spirited")];
char stringpool_str19489[sizeof("peach")];
char stringpool_str19505[sizeof("adoringly")];
char stringpool_str19512[sizeof("rapturously")];
char stringpool_str19553[sizeof("accomplish")];
char stringpool_str19622[sizeof("gallantly")];
char stringpool_str19631[sizeof("grateful")];
char stringpool_str19659[sizeof("cherub")];
char stringpool_str19662[sizeof("gleefully")];
char stringpool_str19725[sizeof("playfully")];
char stringpool_str19801[sizeof("thriving")];
char stringpool_str19893[sizeof("survival")];
char stringpool_str19895[sizeof("amusingly")];
char stringpool_str19923[sizeof("peppy")];
char stringpool_str19971[sizeof("gorgeous")];
char stringpool_str19998[sizeof("vouch")];
char stringpool_str20006[sizeof("eloquently")];
char stringpool_str20027[sizeof("vivacious")];
char stringpool_str20028[sizeof("undisputed")];
char stringpool_str20043[sizeof("chivalrous")];
char stringpool_str20089[sizeof("uplifting")];
char stringpool_str20103[sizeof("glamorous")];
char stringpool_str20179[sizeof("supportive")];
char stringpool_str20239[sizeof("empathy")];
char stringpool_str20260[sizeof("smilingly")];
char stringpool_str20315[sizeof("worth-while")];
char stringpool_str20325[sizeof("feature-rich")];
char stringpool_str20346[sizeof("enthusiast")];
char stringpool_str20349[sizeof("worth")];
char stringpool_str20355[sizeof("undisputable")];
char stringpool_str20361[sizeof("well-run")];
char stringpool_str20469[sizeof("well-positioned")];
char stringpool_str20474[sizeof("praiseworthy")];
char stringpool_str20476[sizeof("invigorate")];
char stringpool_str20571[sizeof("thankful")];
char stringpool_str20620[sizeof("zenith")];
char stringpool_str20655[sizeof("enrich")];
char stringpool_str20740[sizeof("gratitude")];
char stringpool_str20747[sizeof("well-known")];
char stringpool_str20761[sizeof("approve")];
char stringpool_str20762[sizeof("flexibility")];
char stringpool_str20773[sizeof("whoa")];
char stringpool_str20801[sizeof("enthusiasm")];
char stringpool_str20855[sizeof("euphoria")];
char stringpool_str20859[sizeof("wowing")];
char stringpool_str20903[sizeof("lawfully")];
char stringpool_str20928[sizeof("lush")];
char stringpool_str20966[sizeof("rightful")];
char stringpool_str21017[sizeof("navigable")];
char stringpool_str21039[sizeof("exquisite")];
char stringpool_str21054[sizeof("exhilarate")];
char stringpool_str21065[sizeof("smooth")];
char stringpool_str21066[sizeof("exhilaration")];
char stringpool_str21070[sizeof("achievements")];
char stringpool_str21094[sizeof("achievement")];
char stringpool_str21214[sizeof("whooa")];
char stringpool_str21301[sizeof("peacefully")];
char stringpool_str21308[sizeof("thumbs-up")];
char stringpool_str21331[sizeof("savvy")];
char stringpool_str21430[sizeof("sharp")];
char stringpool_str21459[sizeof("glorious")];
char stringpool_str21540[sizeof("relish")];
char stringpool_str21604[sizeof("upliftingly")];
char stringpool_str21613[sizeof("delighted")];
char stringpool_str21616[sizeof("delight")];
char stringpool_str21651[sizeof("graceful")];
char stringpool_str21658[sizeof("enlighten")];
char stringpool_str21668[sizeof("delightfulness")];
char stringpool_str21672[sizeof("enlightenment")];
char stringpool_str21782[sizeof("goodwill")];
char stringpool_str21800[sizeof("champ")];
char stringpool_str21918[sizeof("exceptional")];
char stringpool_str21943[sizeof("champion")];
char stringpool_str22098[sizeof("invigorating")];
char stringpool_str22156[sizeof("amazingly")];
char stringpool_str22259[sizeof("survivor")];
char stringpool_str22336[sizeof("generously")];
char stringpool_str22368[sizeof("enthusiastic")];
char stringpool_str22452[sizeof("approval")];
char stringpool_str22548[sizeof("rich")];
char stringpool_str22565[sizeof("euphoric")];
char stringpool_str22610[sizeof("upheld")];
char stringpool_str22660[sizeof("uphold")];
char stringpool_str22669[sizeof("delightful")];
char stringpool_str22676[sizeof("exhilarating")];
char stringpool_str22694[sizeof("lavishly")];
char stringpool_str22754[sizeof("cherish")];
char stringpool_str22763[sizeof("achievable")];
char stringpool_str22771[sizeof("gratefully")];
char stringpool_str22779[sizeof("gracious")];
char stringpool_str22798[sizeof("graciousness")];
char stringpool_str22850[sizeof("phenomenal")];
char stringpool_str23109[sizeof("chivalry")];
char stringpool_str23317[sizeof("powerful")];
char stringpool_str23387[sizeof("noteworthy")];
char stringpool_str23465[sizeof("enthusiastically")];
char stringpool_str23488[sizeof("undisputably")];
char stringpool_str23651[sizeof("virtuous")];
char stringpool_str23807[sizeof("insightful")];
char stringpool_str23826[sizeof("picturesque")];
char stringpool_str23984[sizeof("winning")];
char stringpool_str23997[sizeof("euphorically")];
char stringpool_str24018[sizeof("improving")];
char stringpool_str24053[sizeof("exceptionally")];
char stringpool_str24106[sizeof("rightfully")];
char stringpool_str24116[sizeof("gorgeously")];
char stringpool_str24131[sizeof("eye-catch")];
char stringpool_str24174[sizeof("exquisitely")];
char stringpool_str24181[sizeof("achievible")];
char stringpool_str24191[sizeof("exhilaratingly")];
char stringpool_str24348[sizeof("willingness")];
char stringpool_str24499[sizeof("dashing")];
char stringpool_str24634[sizeof("gaining")];
char stringpool_str24791[sizeof("gracefully")];
char stringpool_str24804[sizeof("delightfully")];
char stringpool_str24826[sizeof("whoooa")];
char stringpool_str24844[sizeof("top-notch")];
char stringpool_str24909[sizeof("productive")];
char stringpool_str24932[sizeof("thumb-up")];
char stringpool_str24937[sizeof("wow")];
char stringpool_str24943[sizeof("unwavering")];
char stringpool_str24985[sizeof("phenomenally")];
char stringpool_str25149[sizeof("wholesome")];
char stringpool_str25169[sizeof("exemplary")];
char stringpool_str25499[sizeof("examplary")];
char stringpool_str25538[sizeof("evaluative")];
char stringpool_str25604[sizeof("gloriously")];
char stringpool_str25942[sizeof("insightfully")];
char stringpool_str25964[sizeof("willing")];
char stringpool_str26273[sizeof("glow")];
char stringpool_str26457[sizeof("powerfully")];
char stringpool_str26600[sizeof("wealthy")];
char stringpool_str26924[sizeof("graciously")];
char stringpool_str27220[sizeof("posh")];
char stringpool_str27796[sizeof("virtuously")];
char stringpool_str28044[sizeof("productively")];
char stringpool_str28274[sizeof("god-given")];
char stringpool_str28756[sizeof("pepping")];
char stringpool_str28825[sizeof("proving")];
char stringpool_str29261[sizeof("lavish")];
char stringpool_str30617[sizeof("willingly")];
char stringpool_str30635[sizeof("gush")];
char stringpool_str30737[sizeof("enough")];
char stringpool_str30910[sizeof("thoughtfulness")];
char stringpool_str30967[sizeof("unselfish")];
char stringpool_str30970[sizeof("sprightly")];
char stringpool_str31217[sizeof("warmth")];
char stringpool_str31375[sizeof("high-quality")];
char stringpool_str31911[sizeof("thoughtful")];
char stringpool_str32175[sizeof("well-wishers")];
char stringpool_str32730[sizeof("glowing")];
char stringpool_str33336[sizeof("unequivocal")];
char stringpool_str34046[sizeof("thoughtfully")];
char stringpool_str34598[sizeof("wholeheartedly")];
char stringpool_str35471[sizeof("unequivocally")];
char stringpool_str37383[sizeof("glowingly")];
};
static const struct stringpool_t stringpool_contents =
{
"zest",
"deft",
"dote",
"cute",
"modern",
"deference",
"endorses",
"endorse",
"endorsed",
"soft",
"modest",
"endorsement",
"refund",
"credence",
"cure",
"restructure",
"serene",
"restructured",
"cuteness",
"stunned",
"refunded",
"entice",
"soundness",
"refine",
"enticed",
"hot",
"refined",
"defender",
"contentment",
"honored",
"honest",
"conscientious",
"refinement",
"soothe",
"heros",
"refreshed",
"tender",
"trusted",
"trust",
"hero",
"merit",
"honor",
"softer",
"hottest",
"ease",
"sane",
"eased",
"quiet",
"cornerstone",
"eases",
"safe",
"meritorious",
"efficient",
"reassure",
"neat",
"mature",
"reassurance",
"quieter",
"sturdier",
"led",
"masters",
"neatest",
"counter-attacks",
"easiness",
"steadiness",
"dedicated",
"earnestness",
"handsome",
"saint",
"master",
"reforms",
"earnest",
"steadiest",
"treasure",
"reformed",
"easiest",
"efficacious",
"remunerate",
"effortless",
"resolute",
"hearten",
"easier",
"eminence",
"a+",
"quaint",
"heartfelt",
"eminent",
"luster",
"assure",
"smitten",
"meticulous",
"defeat",
"defeats",
"resilient",
"humor",
"defeated",
"lead",
"entertains",
"lean",
"entertain",
"leads",
"afford",
"laud",
"attune",
"adore",
"robust",
"adored",
"entranced",
"ardent",
"dead-on",
"endear",
"ardor",
"redeem",
"astonished",
"smart",
"keen",
"reform",
"smartest",
"autonomous",
"humane",
"commend",
"adorer",
"smarter",
"keenness",
"relent",
"dominates",
"dominate",
"dominated",
"kudos",
"steadfastness",
"assurances",
"assurance",
"steadfast",
"miraculous",
"miraculousness",
"danke",
"elite",
"radiance",
"solid",
"relief",
"kindness",
"danken",
"coolest",
"silent",
"radiant",
"noiseless",
"amuse",
"admire",
"clears",
"seamless",
"cleared",
"counter-attack",
"elan",
"substantive",
"clean",
"elate",
"admirer",
"solace",
"like",
"elated",
"clear",
"risk-free",
"liked",
"clearer",
"likes",
"cleanest",
"hale",
"solicitous",
"cleaner",
"salute",
"astonishment",
"talent",
"talents",
"dauntless",
"talented",
"harmless",
"articulate",
"delicate",
"lionhearted",
"monumental",
"clear-cut",
"self-determination",
"stable",
"stainless",
"miracles",
"miracle",
"abound",
"abounds",
"smiles",
"smile",
"affectation",
"fond",
"fun",
"free",
"liberate",
"freed",
"sustainable",
"fine",
"fondness",
"commendable",
"freedoms",
"liberation",
"restructuring",
"admiration",
"kindliness",
"embolden",
"finest",
"streamlined",
"finer",
"affirm",
"noble",
"nimble",
"humble",
"foremost",
"freshest",
"calmness",
"refreshing",
"abundance",
"desiring",
"abundant",
"fresher",
"doubtless",
"strongest",
"stellar",
"fans",
"regard",
"stunning",
"toughest",
"stronger",
"fast",
"enticing",
"feat",
"eagerness",
"tougher",
"slammin",
"honoring",
"eager",
"best",
"first-rate",
"fastest",
"trusting",
"cool",
"surreal",
"err-free",
"secure",
"decent",
"suitable",
"breeze",
"recomend",
"cost-effective",
"carefree",
"dreamland",
"faster",
"bonus",
"interests",
"nice",
"affirmative",
"bonuses",
"boost",
"affirmation",
"fairness",
"fair",
"readable",
"effectiveness",
"effective",
"freedom",
"satisified",
"nicest",
"calm",
"better",
"contribution",
"nicer",
"tingle",
"consistent",
"heartening",
"confident",
"industrious",
"sincere",
"zeal",
"self-satisfaction",
"instructive",
"merriness",
"erudite",
"friendliness",
"first-class",
"correct",
"fame",
"distinctive",
"cure-all",
"famed",
"distinction",
"entertaining",
"heroine",
"heal",
"reaffirmation",
"skilled",
"ebullient",
"desirable",
"renaissance",
"firmer",
"entrancing",
"titillate",
"fearless",
"nourishment",
"affordable",
"adulate",
"hail",
"assuring",
"reaffirm",
"considerate",
"courage",
"toll-free",
"jubilate",
"jubilant",
"honorable",
"irresistible",
"recommendations",
"recommend",
"recommended",
"recommendation",
"courageous",
"courageousness",
"staunchness",
"jubilation",
"satisfies",
"better-known",
"handier",
"satisfied",
"intimate",
"lucid",
"astonishing",
"mesmerizes",
"mesmerize",
"mesmerized",
"delectable",
"hardier",
"remission",
"adorable",
"fluent",
"laudable",
"hallmarks",
"roomier",
"fanfare",
"brainiest",
"sleek",
"flutter",
"merriment",
"educated",
"sensations",
"memorable",
"sensation",
"affectionate",
"affection",
"felicitate",
"attentive",
"cost-saving",
"cajole",
"felicitous",
"reliable",
"adroit",
"bless",
"striking",
"inestimable",
"boom",
"jubiliant",
"congratulations",
"idealize",
"congratulate",
"congratulation",
"admiring",
"amenable",
"flatter",
"immense",
"bliss",
"ennoble",
"restful",
"romanticize",
"selective",
"boundless",
"commitment",
"bolster",
"ilu",
"instrumental",
"afordable",
"blithe",
"acumen",
"remarkable",
"sensible",
"trouble-free",
"elegance",
"quicker",
"hug",
"regal",
"credible",
"skill",
"elegant",
"strong",
"agile",
"serenity",
"tolerable",
"efficiently",
"rock-stars",
"classic",
"tickle",
"amazes",
"amaze",
"amazed",
"matchless",
"deginified",
"durable",
"rock-star",
"hallmark",
"bloom",
"elation",
"blossom",
"retractable",
"breakthroughs",
"rockstars",
"monumentally",
"saintliness",
"admirable",
"tenacity",
"attraction",
"maturity",
"effortlessly",
"easing",
"rockstar",
"tranquil",
"hotcakes",
"hotcake",
"tenderly",
"angel",
"daring",
"beneficent",
"benefits",
"celebrate",
"celebrated",
"tremendously",
"benefit",
"magical",
"meticulously",
"sensational",
"interesting",
"ideal",
"futurestic",
"audible",
"benifits",
"immaculate",
"celebration",
"issue-free",
"bright",
"maturely",
"brighten",
"fragrant",
"brisk",
"futuristic",
"logical",
"tops",
"brightest",
"amazement",
"masterful",
"faultless",
"magic",
"restored",
"brighter",
"redemption",
"sociable",
"nourishing",
"super",
"benefactor",
"affable",
"satisfying",
"record-setting",
"idol",
"succes",
"succeeds",
"enjoys",
"succeed",
"stupendous",
"success",
"successes",
"succeeded",
"luck",
"enjoyed",
"astonishingly",
"indebted",
"affinity",
"concise",
"courteous",
"titillating",
"steadfastly",
"morality",
"tantalize",
"effusion",
"illustrious",
"outshone",
"soulful",
"confidence",
"miraculously",
"sensitive",
"suffices",
"suffice",
"heartily",
"rapt",
"sufficed",
"first-in-class",
"straighten",
"reasoned",
"reclaim",
"outshine",
"straightforward",
"seasoned",
"illumine",
"indulgent",
"ameliorate",
"illuminate",
"heroize",
"satisfactory",
"satisfactorily",
"outsmart",
"rapid",
"sublime",
"oasis",
"relaxed",
"astutely",
"ebullience",
"stunningly",
"mesmerizing",
"ardently",
"enticingly",
"triumphant",
"fecilitous",
"tenacious",
"cleanliness",
"illuminati",
"resplendent",
"stirringly",
"alluring",
"spontaneous",
"soothingly",
"spotless",
"humility",
"reputation",
"solicitously",
"trustingly",
"momentous",
"delicacy",
"tempt",
"brilliant",
"flourishing",
"comprehensive",
"flattering",
"solidarity",
"adulation",
"adjustable",
"handsomely",
"supreme",
"amiable",
"comfort",
"state-of-the-art",
"enjoyment",
"surmount",
"dazzle",
"dazzled",
"facilitate",
"aspire",
"likable",
"liking",
"agreeableness",
"agreeable",
"sustainability",
"blessing",
"reachable",
"magnanimous",
"fertile",
"surpass",
"blameless",
"commendably",
"ecstasies",
"accomodative",
"salutary",
"ergonomical",
"bargain",
"angelic",
"slick",
"elatedly",
"complements",
"complemented",
"complement",
"cooperative",
"subsidizes",
"subsidize",
"subsidized",
"romantic",
"simplest",
"judicious",
"beneficial",
"helped",
"best-selling",
"compliment",
"simpler",
"modesty",
"delicious",
"transparent",
"accurate",
"amicable",
"aspirations",
"feasible",
"successful",
"aspiration",
"edify",
"merry",
"fastest-growing",
"compassionate",
"compassion",
"nifty",
"honesty",
"effectively",
"consistently",
"comfortable",
"ready",
"loyal",
"endorsing",
"dotingly",
"friendly",
"superb",
"fidelity",
"lucrative",
"supurb",
"strikingly",
"luckiness",
"handy",
"luckiest",
"ebulliently",
"halcyon",
"mastery",
"admiringly",
"luckier",
"sagacity",
"lyrical",
"self-respect",
"accolades",
"dynamic",
"accolade",
"hardy",
"satisfy",
"enterprising",
"comfy",
"affordably",
"hilarious",
"roomy",
"securely",
"irresistibly",
"intimacy",
"dependable",
"courageously",
"titillatingly",
"intelligence",
"qualified",
"intelligent",
"daringly",
"balanced",
"succeeding",
"congenial",
"compliant",
"redeeming",
"intelligible",
"laudably",
"reforming",
"long-lasting",
"bountiful",
"mesmerizingly",
"enjoying",
"tantalizing",
"illuminating",
"reasonable",
"tranquility",
"sensationally",
"dignified",
"felicity",
"formidable",
"buoyant",
"frugal",
"respect",
"defeating",
"reliably",
"respite",
"rational",
"flatteringly",
"inestimably",
"ample",
"ambitious",
"fancier",
"congratulatory",
"endearing",
"masterfully",
"beautiful",
"innocuous",
"outstanding",
"soundly",
"magnificence",
"inpressed",
"rosy",
"magnificent",
"reconcile",
"comforting",
"fulfillment",
"stabilize",
"rejoice",
"indulgence",
"tempting",
"courtly",
"spirited",
"significant",
"trendy",
"tidy",
"amity",
"liberty",
"reconciliation",
"sturdy",
"sparkle",
"heroic",
"triumphal",
"remarkably",
"sufficient",
"sensibly",
"beauteous",
"reputable",
"intuitive",
"romantically",
"accessable",
"stately",
"trusty",
"terrific",
"dazzling",
"enjoyable",
"easy",
"brilliances",
"brilliance",
"adroitly",
"steady",
"acclaimed",
"saintly",
"fearlessly",
"majestic",
"rectification",
"contrasty",
"traction",
"jubilantly",
"impress",
"impresses",
"remedy",
"impressed",
"earnestly",
"subsidizing",
"simplifies",
"competitive",
"simplified",
"respectable",
"fantastic",
"fascinate",
"obsessions",
"razor-sharp",
"obsession",
"affability",
"pros",
"pure",
"nobly",
"fiery",
"poise",
"poised",
"proud",
"fascination",
"prudence",
"ecstatic",
"pride",
"prefers",
"preferes",
"assuredly",
"celebratory",
"prefered",
"prudent",
"crisper",
"alluringly",
"preeminent",
"prefer",
"smartly",
"safely",
"infallible",
"acclaim",
"joy",
"immaculately",
"fast-paced",
"neatly",
"intricate",
"harmonize",
"dirt-cheap",
"realizable",
"respectful",
"commodious",
"splendid",
"harmonious",
"bonny",
"mercy",
"masterpieces",
"masterpiece",
"comely",
"beneficiary",
"beneficially",
"enrapt",
"dead-cheap",
"destiny",
"hooray",
"patience",
"hopeful",
"enjoy",
"praise",
"idolize",
"stupendously",
"idolized",
"compact",
"peerless",
"patient",
"beautify",
"backbone",
"engrossing",
"timely",
"conciliate",
"amiabily",
"successfully",
"holy",
"important",
"amiability",
"incredible",
"clearly",
"adaptable",
"cleanly",
"tantalizingly",
"imaginative",
"spectacular",
"trumpet",
"sweet",
"realistic",
"classy",
"triumphantly",
"sweetness",
"majesty",
"justly",
"sweeten",
"tenaciously",
"paradise",
"eyecatching",
"all-around",
"pain-free",
"capable",
"brilliantly",
"painless",
"speedily",
"swift",
"keenly",
"swiftness",
"outstandingly",
"effusive",
"effusiveness",
"reward",
"dawn",
"acclamation",
"rectifying",
"pluses",
"ingenuous",
"kindly",
"plusses",
"revere",
"venerate",
"ecstasy",
"ingenious",
"fantastically",
"accessible",
"reverence",
"resound",
"reverent",
"jolly",
"understandable",
"terrifically",
"polite",
"easy-to-use",
"magnanimously",
"unencumbered",
"hospitable",
"openness",
"feisty",
"politeness",
"desirous",
"unfettered",
"top",
"resourcefulness",
"eagerly",
"outdone",
"outdo",
"stellarly",
"creative",
"motivated",
"entrust",
"pleased",
"pleases",
"constructive",
"problem-free",
"complementary",
"hands-down",
"best-performing",
"cooperatively",
"pleasure",
"divine",
"awe",
"awed",
"problem-solver",
"awsome",
"helpful",
"superior",
"kid-friendly",
"scenic",
"complimentary",
"low-cost",
"cozy",
"unfazed",
"truthfulness",
"stylized",
"saver",
"suave",
"spellbind",
"standout",
"inspire",
"beautifully",
"beautifullly",
"amicably",
"top-quality",
"statuesque",
"superbly",
"compatible",
"heaven",
"feasibly",
"covenant",
"love",
"fondly",
"ecstatically",
"loved",
"loves",
"merrily",
"supurbly",
"amenity",
"consummate",
"finely",
"replaceable",
"lustrous",
"lover",
"lucky",
"pleasant",
"supple",
"regally",
"progress",
"comfortably",
"yay",
"simplifying",
"readily",
"brotherly",
"fascinating",
"sincerely",
"fancinating",
"notably",
"revolutionizes",
"revolutionize",
"awards",
"revolutionized",
"snazzy",
"award",
"correctly",
"preferring",
"awarded",
"humorous",
"lifesaver",
"sumptuous",
"sumptuousness",
"progressive",
"clarity",
"sagely",
"astound",
"astounded",
"enliven",
"handily",
"preferable",
"avid",
"optimism",
"beauty",
"qualify",
"civilize",
"catchy",
"aver",
"humour",
"lucidly",
"revelation",
"portable",
"brainy",
"fairly",
"dependably",
"temptingly",
"beckon",
"idyllic",
"pleasurable",
"staunchly",
"beckons",
"obtainable",
"beckoned",
"nicely",
"valor",
"frolic",
"prize",
"apotheosis",
"poignant",
"dignity",
"dignify",
"perfect",
"knowledgeable",
"swankiest",
"ideally",
"audibly",
"advocates",
"loveliness",
"resourceful",
"advocate",
"protect",
"perfection",
"advocated",
"impassioned",
"swankier",
"fancy",
"clever",
"praising",
"legendary",
"protection",
"luminous",
"low-risk",
"splendor",
"peace",
"opulent",
"reasonably",
"inspiration",
"instantly",
"vibrant",
"unlimited",
"decency",
"affably",
"heroically",
"truthful",
"respectfully",
"accomplishments",
"flashy",
"accomplished",
"rectify",
"ambitiously",
"passion",
"accomplishment",
"passionate",
"revel",
"infallibility",
"marvels",
"accurately",
"marveled",
"magnificently",
"proactive",
"usable",
"equitable",
"self-sufficient",
"patriot",
"unbiased",
"promises",
"striving",
"promise",
"promised",
"premier",
"user-replaceable",
"sufficiently",
"resounding",
"agilely",
"loyalty",
"prominent",
"fine-looking",
"accommodative",
"unforgettable",
"recover",
"swank",
"pre-eminent",
"elevate",
"elegantly",
"fortune",
"affluence",
"fervent",
"affluent",
"advantages",
"advantageous",
"advantage",
"valiant",
"rejuvenate",
"rejuvenated",
"decisive",
"unabashed",
"decisiveness",
"large-capacity",
"fave",
"marvelled",
"renewed",
"outperforms",
"won",
"outperformed",
"marvellous",
"favored",
"unaffected",
"renown",
"pleasing",
"optimal",
"fortuitous",
"renowned",
"wise",
"admirably",
"wins",
"simplify",
"win",
"spellbinding",
"enviable",
"woo",
"favor",
"ecenomical",
"effectual",
"dummy-proof",
"colorful",
"wonders",
"economical",
"savings",
"priceless",
"favorite",
"benevolence",
"unrestricted",
"fascinatingly",
"favorited",
"wonder",
"benevolent",
"winners",
"harmony",
"pinnacle",
"jollify",
"veritable",
"faithfulness",
"convenience",
"convience",
"innovation",
"amicability",
"convient",
"convenient",
"convienient",
"winner",
"inspirational",
"orderly",
"spellbound",
"permissible",
"cohere",
"vigilance",
"individualized",
"vigilant",
"infallibly",
"cheer",
"stimulates",
"multi-purpose",
"stimulate",
"speedy",
"godsend",
"good",
"diversified",
"coherence",
"worthiness",
"coherent",
"goood",
"astounding",
"palatial",
"shine",
"outstrip",
"goodness",
"harmoniously",
"marvel",
"impeccable",
"famous",
"outperform",
"gifted",
"brave",
"stimulative",
"grin",
"fortunate",
"refresh",
"optimistic",
"energize",
"capability",
"versatile",
"god-send",
"sporty",
"enrichment",
"applaud",
"vouchsafe",
"thinner",
"conciliatory",
"chaste",
"trophy",
"incredibly",
"spectacularly",
"happiness",
"everlasting",
"beloved",
"grand",
"gems",
"gain",
"gains",
"happier",
"gained",
"great",
"gentle",
"prettily",
"greatness",
"greatest",
"sincerity",
"unreal",
"gentlest",
"agility",
"punctual",
"peps",
"exonerate",
"valuable",
"works",
"irreplaceable",
"worked",
"encourage",
"dumbfounded",
"smoothes",
"encouragement",
"revitalize",
"fruitful",
"best-known",
"smoothest",
"mind-blowing",
"heartwarming",
"warmer",
"flawless",
"smoother",
"supremely",
"unmatched",
"invulnerable",
"crisp",
"receptive",
"ingenuously",
"exult",
"enthralled",
"profound",
"ingeniously",
"precise",
"unassailable",
"charm",
"advanced",
"impartial",
"agreeably",
"unbeatable",
"guidance",
"gem",
"proper",
"auspicious",
"faithful",
"homage",
"astonish",
"fabulous",
"glee",
"verifiable",
"youthful",
"warm",
"pardon",
"gold",
"golden",
"exalted",
"exalt",
"amply",
"luxuriate",
"useable",
"luxuriant",
"splendidly",
"skillful",
"rejuvenating",
"appeal",
"exultant",
"extol",
"glisten",
"exellent",
"superiority",
"trump",
"eulogize",
"guarantee",
"exultation",
"glitter",
"diligence",
"spellbindingly",
"diligent",
"glad",
"outperforming",
"promoter",
"exuberant",
"galore",
"peaceable",
"gladden",
"gladness",
"attractive",
"personages",
"panoramic",
"plentiful",
"user-friendly",
"prominence",
"jovial",
"warmhearted",
"work",
"electrify",
"supremacy",
"festive",
"pampers",
"personalized",
"pampered",
"rejoicing",
"pamperedness",
"exaltation",
"revolutionary",
"fervid",
"convincing",
"pamper",
"popular",
"trustworthiness",
"sumptuously",
"divinely",
"sparkling",
"lovable",
"loving",
"believeable",
"fortitude",
"astoundingly",
"responsibly",
"preferably",
"glimmer",
"painlessly",
"non-violence",
"winnable",
"non-violent",
"effusively",
"available",
"originality",
"exceed",
"thrills",
"civility",
"joyous",
"exceeds",
"thrilled",
"exceeded",
"right",
"fresh",
"heavenly",
"stimulating",
"rightness",
"togetherness",
"piety",
"enthral",
"enthrall",
"righten",
"altruistic",
"pleasurably",
"deservedly",
"tough",
"reverently",
"excite",
"excitedness",
"excited",
"thrift",
"blissful",
"excites",
"overture",
"foresight",
"excitement",
"ethical",
"supports",
"supported",
"support",
"influential",
"detachable",
"inventive",
"favorable",
"ingenuity",
"rapture",
"excels",
"faith",
"exceled",
"thank",
"supporter",
"richness",
"charming",
"extoll",
"genuine",
"raptureous",
"well-received",
"truthfully",
"shimmering",
"pleasingly",
"guiltless",
"diplomatic",
"excelent",
"dumbfounding",
"rapport",
"well-intentioned",
"passionately",
"richer",
"well-informed",
"cherished",
"savior",
"lighter",
"self-sufficiency",
"manageable",
"encouraging",
"distinguished",
"stability",
"cleverly",
"invaluable",
"pleasantly",
"grace",
"enhances",
"enhance",
"enhanced",
"well-established",
"nourish",
"enhancement",
"stylishly",
"humourous",
"awesome",
"awesomeness",
"recovery",
"workable",
"adaptive",
"well-regarded",
"adulatory",
"humorously",
"believable",
"capably",
"staunch",
"well",
"better-than-expected",
"enjoyably",
"prodigious",
"cashbacks",
"advantageously",
"evocative",
"thrill",
"unabashedly",
"appreciates",
"appreciate",
"appreciative",
"appreciated",
"genial",
"well-bred",
"glistening",
"flourish",
"unparalleled",
"poetic",
"exalting",
"enchanted",
"enchant",
"charisma",
"light-hearted",
"fortuitously",
"enviably",
"altruistically",
"integrated",
"poeticize",
"fast-growing",
"unity",
"breathlessness",
"merciful",
"rewarding",
"variety",
"pretty",
"impartially",
"impartiality",
"geekier",
"zippy",
"rejoicingly",
"world-famous",
"convincingly",
"deserving",
"proficient",
"conveniently",
"continuity",
"prudently",
"glitz",
"gallant",
"unconditional",
"marvelous",
"marvelousness",
"upbeat",
"excel",
"overtakes",
"well-behaved",
"overtake",
"windfall",
"overtaken",
"generosity",
"glimmering",
"excelled",
"excellent",
"well-made",
"impeccably",
"well-mannered",
"exuberance",
"happy",
"patriotic",
"fortunately",
"nurturing",
"compactly",
"patiently",
"novelty",
"foolproof",
"wonderful",
"appreciable",
"cashback",
"sweetly",
"versatility",
"inspiring",
"meaningful",
"outwit",
"prosperous",
"law-abiding",
"prosper",
"fervor",
"excallent",
"gainful",
"well-managed",
"breakthrough",
"supporting",
"exciting",
"intrigue",
"principled",
"joyful",
"energy-efficient",
"shimmeringly",
"engaging",
"dexterous",
"hallowed",
"famously",
"extraordinary",
"extraordinarily",
"ultra-crisp",
"wonderous",
"peacekeepers",
"well-balanced",
"encouragingly",
"groundbreaking",
"integral",
"excellant",
"envy",
"prompt",
"godlike",
"prolific",
"beckoning",
"faithfully",
"gusto",
"gooood",
"gleeful",
"well-educated",
"upgraded",
"chic",
"bravo",
"playful",
"empowerment",
"smoothly",
"energetic",
"prowess",
"suavely",
"empower",
"charitable",
"ovation",
"skillfully",
"luxurious",
"well-backlit",
"imaculate",
"positives",
"properly",
"positive",
"triumph",
"jaw-droping",
"impressiveness",
"impressive",
"exuberantly",
"uplift",
"well-being",
"evenly",
"enchanting",
"upliftment",
"attractively",
"rewardingly",
"openly",
"pep",
"leading",
"pepped",
"adoring",
"charismatic",
"twinkly",
"levity",
"persevere",
"proves",
"proven",
"overjoyed",
"blockbuster",
"profuse",
"promising",
"wisdom",
"gratifies",
"unquestionable",
"charmingly",
"gratified",
"purify",
"trustworthy",
"hard-working",
"overtaking",
"upgradeable",
"fashionable",
"flawlessly",
"lower-priced",
"captivate",
"witty",
"swanky",
"perseverance",
"authentic",
"lovely",
"enrapture",
"enraptured",
"profoundly",
"amusing",
"breathtaking",
"irreproachable",
"lively",
"blissfully",
"gratification",
"propitious",
"perfectly",
"fabulously",
"exultingly",
"healthful",
"time-honored",
"cushy",
"darling",
"fervidly",
"gutsy",
"invincible",
"shiny",
"excellence",
"avidly",
"vibrantly",
"eye-catching",
"revive",
"revives",
"paramount",
"intriguing",
"smiling",
"raptureously",
"joyously",
"exaltingly",
"bravery",
"diligently",
"virtue",
"vivid",
"upscale",
"mightily",
"calming",
"headway",
"invaluablely",
"appealing",
"wonderfully",
"flexible",
"prodigy",
"adequate",
"eloquence",
"eloquent",
"energy-saving",
"pamperedly",
"inviolate",
"devout",
"responsive",
"victorious",
"righteous",
"righteousness",
"fervently",
"purposeful",
"valiantly",
"prodigiously",
"upgradable",
"sweeping",
"geeky",
"sexy",
"eyecatch",
"appreciatively",
"enchantingly",
"undaunted",
"spiritual",
"rapturous",
"beutifully",
"mercifully",
"expansive",
"worthy",
"proficiently",
"well-rounded",
"gratifying",
"excitingly",
"glory",
"cheery",
"unrivaled",
"spacious",
"marvelously",
"bullish",
"maneuverable",
"uncomplicated",
"joyfully",
"booming",
"excellently",
"stylish",
"unbound",
"adventuresome",
"ftw",
"adventurous",
"happily",
"wisely",
"luxury",
"breathtakingly",
"gaily",
"healthy",
"captivating",
"prosperity",
"inviolable",
"overtook",
"lovably",
"eventful",
"gaiety",
"protective",
"profusion",
"goodly",
"viewable",
"intriguingly",
"appropriate",
"dexterously",
"wonderously",
"low-price",
"low-priced",
"empathize",
"thrifty",
"wieldy",
"prestige",
"expeditiously",
"prestigious",
"thrilling",
"exceeding",
"revival",
"precisely",
"cheapest",
"wows",
"welcome",
"cheaper",
"snappy",
"trivially",
"wowed",
"sharpest",
"amazing",
"warmly",
"sharper",
"expertly",
"authoritative",
"exaltedly",
"invincibility",
"brand-new",
"luxuriously",
"fav",
"prospros",
"impressively",
"promptly",
"dextrous",
"useful",
"wondrous",
"cohesive",
"gratify",
"sweetheart",
"gratifyingly",
"awestruck",
"thrive",
"favour",
"innovative",
"unquestionably",
"privilege",
"privileged",
"rightly",
"peaceful",
"plush",
"generous",
"enthuse",
"polished",
"genius",
"fashionably",
"lawful",
"gladly",
"mighty",
"topnotch",
"well-connected",
"excitedly",
"propitiously",
"sophisticated",
"jaw-dropping",
"excellency",
"glorify",
"improves",
"grandeur",
"improve",
"improvements",
"improved",
"improvement",
"visionary",
"worthwhile",
"positively",
"undamaged",
"thrillingly",
"exceedingly",
"victory",
"leverage",
"gumption",
"exemplar",
"inexpensive",
"awesomely",
"precious",
"providence",
"helping",
"richly",
"gainfully",
"easygoing",
"righteously",
"cheerful",
"examplar",
"wellbeing",
"high-spirited",
"peach",
"adoringly",
"rapturously",
"accomplish",
"gallantly",
"grateful",
"cherub",
"gleefully",
"playfully",
"thriving",
"survival",
"amusingly",
"peppy",
"gorgeous",
"vouch",
"eloquently",
"vivacious",
"undisputed",
"chivalrous",
"uplifting",
"glamorous",
"supportive",
"empathy",
"smilingly",
"worth-while",
"feature-rich",
"enthusiast",
"worth",
"undisputable",
"well-run",
"well-positioned",
"praiseworthy",
"invigorate",
"thankful",
"zenith",
"enrich",
"gratitude",
"well-known",
"approve",
"flexibility",
"whoa",
"enthusiasm",
"euphoria",
"wowing",
"lawfully",
"lush",
"rightful",
"navigable",
"exquisite",
"exhilarate",
"smooth",
"exhilaration",
"achievements",
"achievement",
"whooa",
"peacefully",
"thumbs-up",
"savvy",
"sharp",
"glorious",
"relish",
"upliftingly",
"delighted",
"delight",
"graceful",
"enlighten",
"delightfulness",
"enlightenment",
"goodwill",
"champ",
"exceptional",
"champion",
"invigorating",
"amazingly",
"survivor",
"generously",
"enthusiastic",
"approval",
"rich",
"euphoric",
"upheld",
"uphold",
"delightful",
"exhilarating",
"lavishly",
"cherish",
"achievable",
"gratefully",
"gracious",
"graciousness",
"phenomenal",
"chivalry",
"powerful",
"noteworthy",
"enthusiastically",
"undisputably",
"virtuous",
"insightful",
"picturesque",
"winning",
"euphorically",
"improving",
"exceptionally",
"rightfully",
"gorgeously",
"eye-catch",
"exquisitely",
"achievible",
"exhilaratingly",
"willingness",
"dashing",
"gaining",
"gracefully",
"delightfully",
"whoooa",
"top-notch",
"productive",
"thumb-up",
"wow",
"unwavering",
"phenomenally",
"wholesome",
"exemplary",
"examplary",
"evaluative",
"gloriously",
"insightfully",
"willing",
"glow",
"powerfully",
"wealthy",
"graciously",
"posh",
"virtuously",
"productively",
"god-given",
"pepping",
"proving",
"lavish",
"willingly",
"gush",
"enough",
"thoughtfulness",
"unselfish",
"sprightly",
"warmth",
"high-quality",
"thoughtful",
"well-wishers",
"glowing",
"unequivocal",
"thoughtfully",
"wholeheartedly",
"unequivocally",
"glowingly"
};
#define stringpool ((const char *) &stringpool_contents)
static const int wordlist[] =
{
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str84,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str94,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str99,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str119,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str121,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str124,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str148,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str152,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str158,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str164,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str166,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str181,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str186,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str188,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str189,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str196,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str201,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str202,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str203,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str217,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str218,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str221,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str224,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str231,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str232,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str233,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str242,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str243,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str261,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str277,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str281,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str283,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str285,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str301,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str310,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str314,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str326,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str332,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str335,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str339,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str340,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str350,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str361,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str362,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str379,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str389,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str390,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str395,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str396,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str400,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str404,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str431,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str439,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str448,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str449,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str461,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str466,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str472,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str478,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str508,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str532,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str552,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str575,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str583,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str585,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str589,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str591,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str593,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str600,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str601,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str602,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str607,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str609,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str613,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str618,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str622,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str636,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str655,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str660,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str693,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str712,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str716,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str718,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str722,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str736,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str749,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str797,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str801,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str806,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str807,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str810,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str821,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str822,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str824,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str830,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str838,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str844,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str845,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str854,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str859,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str860,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str861,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str909,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str911,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str920,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str926,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str936,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str939,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str941,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str942,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str976,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str980,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1016,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1030,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1035,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1049,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1056,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1068,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1075,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1081,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1092,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1106,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1112,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1123,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1126,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1134,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1138,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1154,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1170,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1183,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1195,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1199,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1204,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1210,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1214,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1224,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1225,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1228,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1230,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1231,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1248,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1250,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1257,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1271,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1307,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1309,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1310,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1351,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1361,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1363,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1382,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1403,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1404,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1416,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1430,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1435,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1442,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1446,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1448,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1451,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1455,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1458,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1459,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1462,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1469,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1473,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1479,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1495,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1517,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1521,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1522,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1526,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1527,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1539,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1543,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1553,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1565,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1568,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1571,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1580,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1584,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1598,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1601,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1609,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1623,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1627,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1646,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1662,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1671,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1675,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1691,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1719,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1728,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1739,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1748,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1750,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1756,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1779,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1798,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1811,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1813,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1815,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1818,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1820,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1825,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1828,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1851,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1866,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1870,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1871,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1875,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1876,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1891,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1908,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1913,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1923,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1935,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1939,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1948,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1953,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1957,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1964,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1969,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1977,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1979,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str1991,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2003,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2008,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2013,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2014,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2018,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2019,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2049,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2052,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2062,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2063,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2095,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2104,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2115,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2117,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2118,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2134,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2142,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2143,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2161,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2171,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2178,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2191,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2198,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2199,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2208,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2209,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2211,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2215,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2222,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2239,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2246,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2247,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2255,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2256,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2273,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2279,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2283,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2286,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2287,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2292,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2310,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2311,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2314,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2326,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2327,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2330,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2331,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2338,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2340,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2347,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2349,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2377,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2379,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2397,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2399,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2402,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2410,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2422,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2431,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2432,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2454,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2459,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2463,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2465,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2469,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2472,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2475,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2479,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2483,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2491,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2519,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2534,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2549,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2551,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2560,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2569,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2578,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2579,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2585,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2592,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2599,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2603,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2608,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2609,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2617,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2639,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2642,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2647,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2649,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2650,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2655,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2659,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2661,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2669,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2685,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2689,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2696,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2709,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2712,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2722,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2730,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2732,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2736,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2740,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2766,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2778,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2782,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2788,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2795,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2810,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2812,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2813,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2816,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2828,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2829,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2835,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2862,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2869,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2879,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2902,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2917,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2948,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2953,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2954,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2967,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2990,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str2997,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3005,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3012,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3026,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3034,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3045,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3068,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3074,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3085,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3088,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3104,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3119,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3128,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3130,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3131,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3132,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3144,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3148,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3153,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3167,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3200,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3205,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3207,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3217,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3229,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3232,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3234,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3253,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3282,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3286,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3295,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3304,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3341,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3381,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3389,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3396,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3417,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3423,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3447,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3448,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3455,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3471,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3474,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3502,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3511,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3515,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3526,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3534,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3554,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3559,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3562,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3565,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3567,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3571,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3587,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3589,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3590,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3597,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3653,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3657,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3660,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3665,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3687,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3696,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3703,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3708,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3715,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3729,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3734,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3776,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3780,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3786,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3800,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3801,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3802,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3831,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3837,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3841,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3851,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3855,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3871,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3880,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3898,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3904,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3910,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3920,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3922,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3937,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3950,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3959,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3974,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str3978,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4000,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4017,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4018,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4033,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4036,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4043,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4071,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4076,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4093,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4103,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4104,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4120,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4122,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4125,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4129,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4130,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4144,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4149,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4160,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4169,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4173,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4181,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4183,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4188,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4196,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4200,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4207,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4211,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4214,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4217,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4221,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4233,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4240,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4242,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4246,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4247,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4249,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4254,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4257,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4261,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4281,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4286,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4301,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4305,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4310,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4311,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4319,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4321,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4327,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4329,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4334,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4339,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4342,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4348,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4350,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4365,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4376,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4380,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4381,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4385,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4386,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4387,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4398,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4399,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4402,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4409,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4423,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4424,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4426,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4427,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4443,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4453,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4456,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4460,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4462,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4474,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4476,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4480,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4486,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4510,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4516,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4520,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4523,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4524,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4536,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4538,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4546,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4555,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4565,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4569,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4573,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4582,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4603,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4613,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4617,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4618,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4619,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4621,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4626,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4635,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4638,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4640,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4641,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4651,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4654,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4666,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4704,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4715,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4723,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4727,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4728,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4733,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4738,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4752,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4768,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4797,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4803,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4824,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4828,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4839,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4845,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4857,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4861,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4870,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4873,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4874,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4892,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4893,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4909,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4929,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4935,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4938,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4939,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4944,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4967,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4982,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4986,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str4991,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5022,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5032,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5039,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5061,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5067,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5078,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5091,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5102,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5116,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5120,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5126,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5141,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5169,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5174,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5180,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5187,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5202,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5211,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5213,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5276,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5280,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5297,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5298,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5303,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5312,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5316,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5325,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5326,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5334,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5349,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5350,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5359,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5366,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5374,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5391,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5422,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5453,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5472,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5489,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5498,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5507,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5516,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5541,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5542,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5586,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5592,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5607,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5608,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5616,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5624,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5625,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5634,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5638,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5641,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5668,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5669,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5671,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5675,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5678,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5694,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5695,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5698,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5704,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5706,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5708,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5714,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5718,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5720,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5729,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5776,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5783,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5809,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5816,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5825,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5826,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5828,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5840,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5847,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5866,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5868,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5875,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5907,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5925,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5927,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5948,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5961,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str5967,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6017,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6024,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6039,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6047,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6069,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6075,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6091,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6092,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6094,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6105,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6111,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6143,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6145,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6151,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6178,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6187,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6201,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6206,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6229,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6230,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6237,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6241,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6245,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6265,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6267,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6272,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6279,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6294,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6308,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6312,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6316,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6318,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6328,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6335,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6337,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6362,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6386,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6394,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6405,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6423,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6428,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6434,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6446,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6452,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6467,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6472,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6485,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6489,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6496,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6497,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6502,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6503,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6514,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6515,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6522,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6526,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6529,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6535,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6540,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6568,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6573,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6580,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6586,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6587,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6624,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6625,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6633,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6645,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6651,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6655,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6669,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6677,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6704,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6716,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6723,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6734,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6744,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6750,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6759,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6767,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6771,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6773,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6777,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6793,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6860,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6862,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6871,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6875,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6881,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6882,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6889,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6897,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6909,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6913,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6923,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6938,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6941,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6966,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6974,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str6989,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7007,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7023,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7027,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7029,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7030,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7036,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7057,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7074,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7080,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7085,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7089,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7090,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7109,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7124,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7133,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7137,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7143,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7151,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7157,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7161,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7162,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7163,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7168,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7181,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7182,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7195,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7203,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7216,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7219,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7231,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7249,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7252,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7264,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7269,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7299,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7304,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7308,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7312,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7314,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7315,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7318,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7321,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7329,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7332,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7340,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7368,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7377,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7383,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7384,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7386,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7390,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7408,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7410,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7419,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7421,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7422,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7436,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7442,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7446,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7456,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7460,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7465,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7473,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7483,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7491,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7501,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7530,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7556,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7584,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7592,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7597,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7609,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7646,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7652,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7657,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7661,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7670,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7684,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7686,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7698,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7705,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7720,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7734,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7736,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7766,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7768,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7769,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7780,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7787,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7791,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7792,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7815,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7827,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7834,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7848,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7877,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7885,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7886,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7889,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7898,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7913,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7917,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7924,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7942,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7954,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7961,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7968,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7986,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str7998,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8005,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8013,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8019,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8033,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8050,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8056,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8058,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8065,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8069,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8073,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8079,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8105,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8107,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8112,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8114,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8116,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8120,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8126,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8141,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8154,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8157,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8160,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8164,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8165,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8183,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8184,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8194,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8203,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8204,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8207,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8211,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8226,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8237,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8240,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8242,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8244,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8260,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8266,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8317,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8318,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8320,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8323,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8324,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8327,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8329,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8341,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8348,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8358,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8375,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8381,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8386,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8398,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8409,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8424,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8429,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8430,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8436,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8440,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8441,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8442,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8444,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8447,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8449,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8464,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8465,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8467,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8468,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8476,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8486,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8494,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8507,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8524,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8531,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8532,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8537,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8554,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8556,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8563,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8580,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8583,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8591,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8600,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8605,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8610,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8617,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8634,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8635,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8639,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8650,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8654,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8661,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8665,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8669,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8672,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8675,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8678,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8681,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8685,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8692,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8693,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8709,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8710,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8716,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8720,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8733,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8749,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8752,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8753,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8765,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8768,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8769,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8782,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8785,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8795,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8807,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8814,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8819,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8822,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8835,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8842,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8871,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8891,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8895,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8937,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8942,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8949,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8954,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8956,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8958,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8963,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8965,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8967,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8969,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8983,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str8992,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9006,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9014,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9043,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9057,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9070,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9074,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9079,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9094,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9099,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9105,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9114,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9116,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9125,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9126,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9127,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9129,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9139,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9142,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9145,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9148,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9149,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9159,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9162,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9180,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9185,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9187,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9189,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9193,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9195,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9212,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9214,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9224,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9253,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9268,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9288,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9300,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9301,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9306,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9336,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9344,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9366,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9371,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9372,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9378,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9384,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9385,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9392,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9395,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9410,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9416,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9417,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9428,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9438,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9444,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9452,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9464,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9467,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9481,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9506,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9537,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9544,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9593,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9594,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9597,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9603,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9612,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9622,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9641,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9646,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9651,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9654,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9659,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9692,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9709,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9714,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9723,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9725,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9736,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9743,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9755,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9773,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9780,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9788,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9794,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9796,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9798,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9800,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9813,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9824,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9830,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9854,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9860,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9868,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9883,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9890,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9905,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9909,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9943,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9945,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9954,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9956,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9958,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9961,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9968,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9970,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9984,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9991,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9995,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str9996,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10000,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10001,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10002,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10015,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10016,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10019,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10025,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10031,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10059,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10065,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10074,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10084,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10094,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10109,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10113,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10126,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10139,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10147,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10148,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10154,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10155,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10163,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10166,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10169,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10187,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10200,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10203,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10205,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10208,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10210,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10213,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10219,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10222,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10227,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10229,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10235,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10238,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10245,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10252,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10262,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10266,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10273,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10275,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10288,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10289,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10294,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10307,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10311,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10313,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10315,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10318,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10319,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10321,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10335,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10336,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10347,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10350,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10372,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10386,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10390,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10392,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10398,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10400,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10404,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10407,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10414,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10417,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10422,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10423,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10431,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10437,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10441,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10470,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10479,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10487,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10495,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10499,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10513,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10515,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10523,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10527,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10529,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10545,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10559,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10581,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10618,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10623,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10624,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10642,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10644,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10647,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10648,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10652,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10676,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10681,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10692,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10697,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10718,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10722,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10728,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10733,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10746,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10755,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10758,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10767,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10775,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10779,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10790,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10792,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10821,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10854,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10866,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10868,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10892,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10895,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10902,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10910,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10919,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10942,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10944,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10950,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10961,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10968,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10978,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10993,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str10994,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11005,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11011,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11015,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11016,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11018,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11024,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11053,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11062,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11097,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11106,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11108,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11112,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11116,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11127,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11129,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11131,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11140,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11141,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11150,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11155,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11159,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11187,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11194,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11198,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11200,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11209,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11211,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11226,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11230,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11251,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11259,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11271,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11323,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11324,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11327,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11340,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11341,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11348,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11381,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11387,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11423,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11446,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11453,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11455,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11457,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11469,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11470,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11491,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11503,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11510,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11511,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11517,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11519,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11526,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11531,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11540,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11551,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11570,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11571,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11581,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11598,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11601,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11624,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11630,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11631,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11633,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11641,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11651,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11657,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11660,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11661,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11663,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11669,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11673,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11701,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11751,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11755,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11765,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11771,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11778,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11780,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11782,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11802,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11805,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11809,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11824,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11825,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11852,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11856,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11857,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11858,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11878,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11887,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11892,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11898,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11901,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11906,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11915,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11919,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11925,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11939,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11945,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11958,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11974,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11975,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11988,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11993,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11994,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11997,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str11999,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12009,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12010,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12025,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12037,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12042,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12052,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12057,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12061,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12069,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12081,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12084,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12085,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12089,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12091,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12096,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12114,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12137,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12139,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12143,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12153,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12154,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12158,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12159,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12164,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12165,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12176,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12197,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12204,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12256,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12277,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12280,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12305,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12307,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12311,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12330,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12331,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12409,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12423,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12427,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12444,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12446,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12447,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12450,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12455,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12463,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12472,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12477,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12480,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12484,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12487,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12490,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12501,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12507,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12510,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12518,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12520,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12538,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12545,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12583,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12585,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12589,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12593,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12594,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12620,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12632,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12637,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12643,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12671,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12687,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12694,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12700,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12702,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12705,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12709,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12715,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12718,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12732,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12738,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12741,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12746,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12754,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12758,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12767,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12769,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12780,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12810,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12831,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12854,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12866,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12867,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12874,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12881,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12897,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12899,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12928,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12931,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12938,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12948,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12973,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str12990,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13056,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13060,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13062,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13066,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13068,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13076,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13097,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13100,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13104,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13106,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13110,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13111,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13114,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13123,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13130,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13131,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13152,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13188,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13210,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13212,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13213,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13220,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13231,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13257,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13258,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13262,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13264,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13266,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13267,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13271,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13281,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13293,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13294,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13324,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13328,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13338,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13344,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13347,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13362,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13368,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13369,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13377,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13401,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13405,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13413,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13427,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13431,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13434,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13435,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13460,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13461,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13465,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13467,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13470,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13511,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13546,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13547,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13565,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13582,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13591,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13604,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13605,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13653,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13661,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13672,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13677,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13687,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13706,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13756,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13759,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13762,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13768,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13779,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13795,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13796,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13809,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13825,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13831,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13833,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13841,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13849,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13884,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13889,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13898,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13940,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13965,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13969,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13984,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str13996,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14002,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14005,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14022,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14025,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14037,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14058,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14060,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14063,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14067,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14069,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14125,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14152,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14161,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14198,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14201,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14241,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14260,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14266,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14301,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14332,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14334,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14338,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14374,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14389,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14405,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14410,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14416,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14447,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14452,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14464,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14498,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14506,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14510,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14522,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14525,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14530,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14542,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14563,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14607,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14633,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14658,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14682,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14684,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14686,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14690,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14692,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14694,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14695,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14696,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14723,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14727,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14728,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14732,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14757,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14766,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14773,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14774,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14787,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14802,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14840,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14852,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14861,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14872,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14878,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14882,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14889,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14919,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14921,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14922,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14925,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14952,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14954,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14957,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14962,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14975,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14977,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14984,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14986,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str14993,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15072,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15128,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15131,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15139,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15145,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15159,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15171,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15173,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15215,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15216,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15218,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15222,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15228,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15241,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15242,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15273,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15275,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15288,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15299,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15311,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15314,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15347,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15354,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15365,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15371,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15395,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15406,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15412,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15415,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15421,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15452,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15491,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15512,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15533,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15541,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15572,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15573,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15594,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15597,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15602,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15607,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15617,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15619,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15630,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15657,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15660,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15688,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15697,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15724,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15773,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15802,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15808,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15829,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15839,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15841,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15843,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15851,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15856,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15872,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15886,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15898,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15906,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15934,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15953,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str15968,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16015,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16017,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16021,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16041,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16059,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16066,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16068,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16102,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16146,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16165,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16167,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16168,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16197,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16247,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16306,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16339,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16372,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16382,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16397,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16430,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16439,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16453,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16455,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16456,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16460,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16481,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16489,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16506,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16518,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16541,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16582,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16584,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16590,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16599,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16607,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16626,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16650,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16659,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16670,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16675,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16713,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16736,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16749,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16759,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16788,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16791,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16868,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16901,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16902,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16935,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16970,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16977,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str16995,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17004,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17038,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17060,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17069,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17085,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17117,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17150,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17162,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17207,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17245,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17251,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17255,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17268,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17279,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17282,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17294,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17335,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17359,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17374,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17384,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17385,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17387,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17427,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17430,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17431,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17440,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17444,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17448,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17492,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17503,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17529,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17536,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17539,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17584,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17592,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17708,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17741,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17747,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17795,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17823,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17830,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17855,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17871,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17883,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17916,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17931,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17951,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17963,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17971,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str17984,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18004,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18043,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18070,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18095,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18115,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18121,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18153,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18161,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18179,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18191,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18215,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18232,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18254,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18264,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18288,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18299,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18304,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18362,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18407,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18422,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18454,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18539,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18564,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18645,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18651,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18659,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18661,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18663,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18668,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18669,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18692,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18777,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18813,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18826,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18842,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18874,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18889,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18938,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18941,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18947,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str18987,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19003,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19027,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19049,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19091,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19103,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19119,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19122,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19142,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19157,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19166,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19317,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19319,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19422,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19489,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19505,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19512,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19553,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19622,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19631,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19659,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19662,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19725,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19801,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19893,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19895,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19923,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19971,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str19998,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20006,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20027,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20028,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20043,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20089,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20103,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20179,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20239,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20260,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20315,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20325,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20346,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20349,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20355,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20361,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20469,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20474,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20476,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20571,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20620,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20655,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20740,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20747,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20761,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20762,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20773,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20801,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20855,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20859,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20903,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20928,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str20966,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21017,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21039,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21054,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21065,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21066,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21070,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21094,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21214,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21301,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21308,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21331,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21430,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21459,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21540,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21604,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21613,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21616,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21651,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21658,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21668,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21672,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21782,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21800,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21918,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str21943,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22098,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22156,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22259,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22336,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22368,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22452,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22548,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22565,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22610,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22660,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22669,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22676,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22694,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22754,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22763,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22771,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22779,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22798,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str22850,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23109,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23317,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23387,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23465,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23488,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23651,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23807,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23826,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23984,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str23997,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24018,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24053,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24106,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24116,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24131,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24174,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24181,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24191,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24348,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24499,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24634,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24791,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24804,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24826,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24844,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24909,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24932,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24937,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24943,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str24985,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25149,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25169,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25499,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25538,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25604,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25942,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str25964,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str26273,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str26457,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str26600,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str26924,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str27220,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str27796,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str28044,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str28274,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str28756,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str28825,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str29261,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30617,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30635,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30737,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30910,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30967,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str30970,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str31217,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str31375,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str31911,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str32175,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str32730,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str33336,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str34046,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str34598,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str35471,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1,
(intptr_t)&((struct stringpool_t *)0)->stringpool_str37383
};
if (len <= POS_MAX_WORD_LENGTH && len >= POS_MIN_WORD_LENGTH)
{
register int key = poshash (str, len);
if (key <= POS_MAX_HASH_VALUE && key >= 0)
{
register int o = wordlist[key];
if (o >= 0)
{
register const char *s = o + stringpool;
if (*str == *s && !strcmp (str + 1, s + 1))
return s;
}
}
}
return 0;
}
|
cran/meanr
|
src/meanr_nthreads.c
|
<filename>src/meanr_nthreads.c
#ifdef _OPENMP
#include <omp.h>
#endif
#include <RNACI.h>
#define MIN(a,b) ((a)<(b)?(a):(b))
static inline int num_threads()
{
int n = 0;
#ifdef _OPENMP
int nth, tl;
#pragma omp parallel
{
nth = omp_get_num_threads();
tl = omp_get_thread_limit();
}
n = MIN(nth, tl);
#else
n = 1;
#endif
return n;
}
SEXP R_meanr_nthreads()
{
SEXP nth;
newRvec(nth, 1, "int");
INT(nth) = num_threads();
unhideGC();
return nth;
}
|
ayushev/aws-cloud-and-xilinx-workshop
|
zynq7k_demo/lib/utils/aws_system_init.c
|
<filename>zynq7k_demo/lib/utils/aws_system_init.c
/*
* Amazon FreeRTOS System Initialization
* Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
#include <stdio.h>
#include "FreeRTOS.h"
#include "aws_system_init.h"
#include "ff.h"
#include "sleep.h"
#include "xil_printf.h"
#include "aws_pkcs11_config.h"
/* Library code. */
extern BaseType_t BUFFERPOOL_Init( void );
extern BaseType_t MQTT_AGENT_Init( void );
extern BaseType_t SOCKETS_Init( void );
#define clientcredentialMQTT_BROKER_ENDPOINT_NAMELEN 255
const char clientcredentialMQTT_BROKER_ENDPOINT[clientcredentialMQTT_BROKER_ENDPOINT_NAMELEN+1];
#define clientcredentialGG_GROUP_NAMELEN 255
const char clientcredentialGG_GROUP[clientcredentialGG_GROUP_NAMELEN+1];
#define rest_NAMELEN 0
char rest[rest_NAMELEN+1];
#define FILE_NAMELEN (clientcredentialGG_GROUP_NAMELEN + 1 + 32)
const char pkcs11configFILE_NAME_CLIENT_CERTIFICATE[FILE_NAMELEN + 1];
const char pkcs11configFILE_NAME_KEY[FILE_NAMELEN + 1];
#define IOT_THING_NAMELEN (clientcredentialGG_GROUP_NAMELEN + 1 + 32)
const char clientcredentialIOT_THING_NAME[IOT_THING_NAMELEN + 1];
#define pkcs11configFILE_NAME_GG_CONFIG "ggconfig.txt"
/*-----------------------------------------------------------*/
/**
* @brief Reads a file containing broker id and group id from local storage.
* The two pieces of information are on separate lines
* Any sequence of non-printable characters is considered a separator
*
* @param[in] pcFileName The name of the file to be read.
*
* @return pdTRUE if data was retrieved successfully from file,
* pdFALSE otherwise.
*/
static BaseType_t ReadGreenGrassInfo( const char * pcFileName)
{
FIL fil;
FRESULT Res;
uint32_t uFileBytesLeft;
UINT N;
uint32_t uLength;
char* pDst;
const int CHAR_EOF = -1;
char c;
int iChar;
BaseType_t SkipLeadingNewlines;
BaseType_t SkipNextRead;
typedef struct BrokerLine {
char* pcDst;
uint32_t uMaxLength;
char* pcName;
} BrokerLine;
BrokerLine pBrokerLines[] = {
{
(char*)&clientcredentialMQTT_BROKER_ENDPOINT[0],
clientcredentialMQTT_BROKER_ENDPOINT_NAMELEN,
"BrokerEndpoint",
},
{
(char*)&clientcredentialGG_GROUP[0],
clientcredentialGG_GROUP_NAMELEN,
"GroupName"
},
{
(char*)&rest[0],
rest_NAMELEN,
"TrailingData"
},
{
0,
0,
0
}
};
BrokerLine* pBL;
Res = f_open(&fil, pcFileName, FA_READ);
if (Res) {
for(;;) {
xil_printf("ERROR: Unable to open file '%s' Res %d\r\n", pcFileName, Res);
sleep(1);
}
return pdFALSE;
}
uFileBytesLeft = fil.fsize;
SkipNextRead = pdFALSE;
rest[0] = 0;
for(pBL = pBrokerLines; pBL->pcDst; pBL++) {
/*
* Each loop parses newline* valid*
*/
for(
SkipLeadingNewlines = pdTRUE, pDst = pBL->pcDst, pBL->pcDst[0] = 0, uLength = 0;
uLength < pBL->uMaxLength;
) {
if(!SkipNextRead) {
if(uFileBytesLeft >= 1) {
uFileBytesLeft--;
/* Read should never hit EOF as we don't read more than fil.fsize bytes */
Res = f_read(&fil, &c, 1, &N);
if((1 != N) || (Res != 0)) {
f_close(&fil);
for(;;) {
xil_printf("ERROR: Read from file %s failed (%d)\r\n", pcFileName, Res);
sleep(1);
}
return pdFALSE;
}
iChar = (int)c & 0xff;
} else {
iChar = CHAR_EOF;
}
}
SkipNextRead = pdFALSE;
if(SkipLeadingNewlines) {
if(CHAR_EOF == iChar) {
break;
} else if(iChar < 32) {
/* Keep looking */
;
} else {
SkipLeadingNewlines = pdFALSE;
SkipNextRead = pdTRUE;
}
} else {
if((CHAR_EOF == iChar) || (iChar < 32)) {
SkipLeadingNewlines = pdTRUE;
*pDst = 0;
break;
} else {
*pDst++ = iChar;
uLength++;
}
}
}
if(((0 == uLength) && (pBL->uMaxLength > 0)) || (uLength > pBL->uMaxLength)) {
f_close(&fil);
for(;;) {
xil_printf("ERROR: File '%s': '%s' %s: maxlen %u\r\n",
pcFileName,
pBL->pcName,
(0 == uLength) ? "missing" : "too long",
pBL->uMaxLength
);
sleep(1);
}
return pdFALSE;
}
pBL->pcDst[pBL->uMaxLength] = 0;
}
f_close(&fil);
pDst = (char*)pkcs11configFILE_NAME_CLIENT_CERTIFICATE;
(void)snprintf(pDst, FILE_NAMELEN + 1,
"%s-node-zynq7k.crt.der",
clientcredentialGG_GROUP
);
pDst[FILE_NAMELEN] = 0;
pDst = (char*)pkcs11configFILE_NAME_KEY;
(void)snprintf(pDst, FILE_NAMELEN + 1,
"%s-node-zynq7k.key.prv.der",
clientcredentialGG_GROUP
);
pDst[FILE_NAMELEN] = 0;
pDst = (char*)clientcredentialIOT_THING_NAME;
(void)snprintf(pDst, IOT_THING_NAMELEN + 1,
"%s-node-zynq7k",
clientcredentialGG_GROUP
);
pDst[IOT_THING_NAMELEN] = 0;
return pdTRUE;
}
/*-----------------------------------------------------------*/
/**
* @brief Initializes Amazon FreeRTOS libraries.
*/
BaseType_t SYSTEM_Init()
{
BaseType_t xResult = pdPASS;
xResult = BUFFERPOOL_Init();
if( xResult == pdPASS )
{
xResult = MQTT_AGENT_Init();
}
if( xResult == pdPASS )
{
xResult = SOCKETS_Init();
}
if(xResult == pdPASS )
{
xResult = ReadGreenGrassInfo(pkcs11configFILE_NAME_GG_CONFIG);
}
return xResult;
}
|
ayushev/aws-cloud-and-xilinx-workshop
|
zynq7k_demo/tests/xilinx/microzed/common/application_code/xilinx_code/memcpy.c
|
/*
* An memcpy() in C which does not use the FPU registers, as the default does.
*/
#include <string.h>
#include <stdint.h>
#ifndef SIMPLE_MEMCPY
#define SIMPLE_MEMCPY ( 0 )
#endif
#ifndef SIMPLE_MEMSET
#define SIMPLE_MEMSET ( 0 )
#endif
#if( SIMPLE_MEMCPY != 0 )
void *memcpy( void *pvDest, const void *pvSource, size_t ulBytes )
{
unsigned char *pcDest = ( unsigned char * ) pvDest, *pcSource = ( unsigned char * ) pvSource;
size_t x;
for( x = 0; x < ulBytes; x++ )
{
*pcDest = *pcSource;
pcDest++;
pcSource++;
}
return pvDest;
}
/*-----------------------------------------------------------*/
#endif /* SIMPLE_MEMCPY */
union xPointer {
uint8_t *u8;
uint16_t *u16;
uint32_t *u32;
uint32_t uint32;
};
#if( SIMPLE_MEMCPY == 0 )
void *memcpy( void *pvDest, const void *pvSource, size_t ulBytes )
{
union xPointer pxDestination;
union xPointer pxSource;
union xPointer pxLastSource;
uint32_t ulAlignBits;
pxDestination.u8 = ( uint8_t * ) pvDest;
pxSource.u8 = ( uint8_t * ) pvSource;
pxLastSource.u8 = pxSource.u8 + ulBytes;
ulAlignBits = ( pxDestination.uint32 & 0x03 ) ^ ( pxSource.uint32 & 0x03 );
if( ( ulAlignBits & 0x01 ) == 0 )
{
if( ( ( pxSource.uint32 & 1 ) != 0 ) && ( pxSource.u8 < pxLastSource.u8 ) )
{
*( pxDestination.u8++ ) = *( pxSource.u8++) ;
}
/* 16-bit aligned here */
if( ( ulAlignBits & 0x02 ) != 0 )
{
uint32_t extra = pxLastSource.uint32 & 0x01ul;
pxLastSource.uint32 &= ~0x01ul;
while( pxSource.u16 < pxLastSource.u16 )
{
*( pxDestination.u16++ ) = *( pxSource.u16++) ;
}
pxLastSource.uint32 |= extra;
}
else
{
int iCount;
uint32_t extra;
if( ( ( pxSource.uint32 & 2 ) != 0 ) && ( pxSource.u8 < pxLastSource.u8 - 1 ) )
{
*( pxDestination.u16++ ) = *( pxSource.u16++) ;
}
// 32-bit aligned
extra = pxLastSource.uint32 & 0x03ul;
pxLastSource.uint32 &= ~0x03ul;
iCount = pxLastSource.u32 - pxSource.u32;
while( iCount > 8 )
{
/* Copy 32 bytes */
/* Normally it doesn't make sense to make this list much longer because
the indexes will get too big, and therefore longer instructions are needed. */
pxDestination.u32[ 0 ] = pxSource.u32[ 0 ];
pxDestination.u32[ 1 ] = pxSource.u32[ 1 ];
pxDestination.u32[ 2 ] = pxSource.u32[ 2 ];
pxDestination.u32[ 3 ] = pxSource.u32[ 3 ];
pxDestination.u32[ 4 ] = pxSource.u32[ 4 ];
pxDestination.u32[ 5 ] = pxSource.u32[ 5 ];
pxDestination.u32[ 6 ] = pxSource.u32[ 6 ];
pxDestination.u32[ 7 ] = pxSource.u32[ 7 ];
pxDestination.u32 += 8;
pxSource.u32 += 8;
iCount -= 8;
}
while( pxSource.u32 < pxLastSource.u32 )
{
*( pxDestination.u32++ ) = *( pxSource.u32++) ;
}
pxLastSource.uint32 |= extra;
}
}
else
{
/* This it the worst alignment, e.g. 0x80000 and 0xA0001,
only 8-bits copying is possible. */
int iCount = pxLastSource.u8 - pxSource.u8;
while( iCount > 8 )
{
/* Copy 8 bytes the hard way */
pxDestination.u8[ 0 ] = pxSource.u8[ 0 ];
pxDestination.u8[ 1 ] = pxSource.u8[ 1 ];
pxDestination.u8[ 2 ] = pxSource.u8[ 2 ];
pxDestination.u8[ 3 ] = pxSource.u8[ 3 ];
pxDestination.u8[ 4 ] = pxSource.u8[ 4 ];
pxDestination.u8[ 5 ] = pxSource.u8[ 5 ];
pxDestination.u8[ 6 ] = pxSource.u8[ 6 ];
pxDestination.u8[ 7 ] = pxSource.u8[ 7 ];
pxDestination.u8 += 8;
pxSource.u8 += 8;
iCount -= 8;
}
}
while( pxSource.u8 < pxLastSource.u8 )
{
*( pxDestination.u8++ ) = *( pxSource.u8++ );
}
return pvDest;
}
#endif /* SIMPLE_MEMCPY == 0 */
/*-----------------------------------------------------------*/
#if( SIMPLE_MEMSET != 0 )
void *memset( void *pvDest, int iValue, size_t ulBytes )
{
unsigned char *pcDest = ( unsigned char * ) pvDest;
size_t x;
for( x = 0; x < ulBytes; x++ )
{
*pcDest = ( unsigned char ) iValue;
pcDest++;
}
return pvDest;
}
#endif /* SIMPLE_MEMSET != 0 */
/*-----------------------------------------------------------*/
#if( SIMPLE_MEMSET == 0 )
void *memset(void *pvDest, int iValue, size_t ulBytes)
{
union xPointer pxDestination;
union xPointer pxLast;
uint32_t ulPattern;
pxDestination.u8 = ( unsigned char * ) pvDest;
pxLast.u8 = pxDestination.u8 + ulBytes;
if( ulBytes >= 8 )
{
uint32_t ulAlignBits;
uint32_t ulExtra;
int iCount;
ulPattern = iValue & 0xff;
ulPattern |= ( ulPattern << 8 ) | ( ulPattern << 16 ) | ( ulPattern << 24 );
ulAlignBits = ( pxDestination.uint32 & 0x03 );
if( ulAlignBits != 0 )
{
ulAlignBits = 4 - ulAlignBits;
while( ulAlignBits-- > 0 )
{
pxDestination.u8[ 0 ] = ( unsigned char )iValue;
pxDestination.u8++;
}
}
/* Strip-off the last 1 up-to 3 bytes because they can not be set in a 32-bit
memory instruction. */
ulExtra = pxLast.uint32 & 0x03ul;
pxLast.uint32 &= ~0x03ul;
iCount = ( int ) ( pxLast.u32 - pxDestination.u32 );
while( iCount > 8 )
{
/* Set 8 * 4 bytes and save some increments */
/* It won't make sense to make this list much longer than 8 assignments. */
pxDestination.u32[ 0 ] = ulPattern;
pxDestination.u32[ 1 ] = ulPattern;
pxDestination.u32[ 2 ] = ulPattern;
pxDestination.u32[ 3 ] = ulPattern;
pxDestination.u32[ 4 ] = ulPattern;
pxDestination.u32[ 5 ] = ulPattern;
pxDestination.u32[ 6 ] = ulPattern;
pxDestination.u32[ 7 ] = ulPattern;
pxDestination.u32 += 8;
iCount -= 8;
}
while( pxDestination.u32 < pxLast.u32 )
{
*( pxDestination.u32++ ) = ulPattern;
}
pxLast.uint32 |= ulExtra;
}
while( pxDestination.u8 < pxLast.u8 )
{
pxDestination.u8[ 0 ] = ( unsigned char ) iValue;
pxDestination.u8++;
}
return pvDest;
}
#endif /* SIMPLE_MEMSET -= 0 */
/*-----------------------------------------------------------*/
|
ayushev/aws-cloud-and-xilinx-workshop
|
zynq7k_demo/demos/xilinx/microzed/common/application_code/xilinx_code/uzed_iot.c
|
/*
* Amazon FreeRTOS MQTT UZed Demo V1.0
* Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/**
* @file uzed_iot.c
* @brief A simple MQTT sensor example for the MicroZed IOT Kit.
*
* It creates an MQTT client that periodically publishes sensor readings to
* MQTT topics at a defined rate.
*
* The demo uses one task. The task implemented by
* prvUZedIotTask() creates the GG MQTT client, subscribes to the
* broker specified by the clientcredentialMQTT_BROKER_ENDPOINT constant,
* performs the publish operations periodically forever.
*/
//////////////////// USER PARAMETERS ////////////////////
/* Sampling period, in ms. Two messages per period: pressure and temperature */
#define SAMPLING_PERIOD_MS 5000
/* Timeout used when establishing a connection, which required TLS
* negotiation. */
#define democonfigMQTT_UZED_TLS_NEGOTIATION_TIMEOUT pdMS_TO_TICKS( 60000 )
/**
* @brief Dimension of the character array buffers used to hold data (strings in
* this case) that is published to and received from the MQTT broker (in the cloud).
*/
#define UZedMAX_DATA_LENGTH 256
/**
* @brief A block time of 0 simply means "don't block".
*/
#define UZedDONT_BLOCK ( ( TickType_t ) 0 )
/**
* @brief If set to 1, use GreenGrass instead of raw MQTT
*/
#define UZED_USE_GG 1
/**
* @brief MQTT client ID.
*
* It must be unique per MQTT broker.
*/
#if UZED_USE_GG
#define UZedCLIENT_ID ( ( const uint8_t * ) "GGUZed" )
#else
#define UZedCLIENT_ID ( ( const uint8_t * ) "MQTTUZed" )
#endif
//////////////////// END USER PARAMETERS ////////////////////
#if SAMPLING_PERIOD_MS < 100
#error Sampling period must be at least 100 ms
#endif
/*-----------------------------------------------------------*/
/* Standard includes. */
#include "string.h"
#include "stdio.h"
#include <stdarg.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "message_buffer.h"
/* MQTT includes. */
#include "aws_mqtt_agent.h"
/* Credentials includes. */
#include "aws_clientcredential.h"
#include "aws_system_init.h"
#include "aws_pkcs11_config.h"
/* Demo includes. */
#include "aws_demo_config.h"
#include "xil_types.h"
#include "xparameters.h"
#include "xstatus.h"
#include "xiic.h"
#include "xgpiops.h"
#include "xspi_l.h"
#include "xemacps.h"
#include "uzed_iot.h"
#if UZED_USE_GG
#include "aws_ggd_config.h"
#include "aws_ggd_config_defaults.h"
#include "aws_greengrass_discovery.h"
#endif
/*-----------------------------------------------------------*/
// System parameters for the MicroZed IOT kit
#if UZED_USE_GG
#define GG_DISCOVERY_FILE_SIZE 4096
#endif
/**
* @brief This is the LPS25HB on the Arduino shield board
*/
#define BAROMETER_SLAVE_ADDRESS 0x5D
/**
* @brief This is the HTS221 on the Arduino shield board
*/
#define HYGROMETER_SLAVE_ADDRESS 0x5F
/**
* @brief LED pin represents connection state
*/
#define LED_PIN 47
/**
* @brief Barometer register defines
*/
#define BAROMETER_REG_REF_P_XL 0x15
#define BAROMETER_REG_REF_P_L 0x16
#define BAROMETER_REG_REF_P_H 0x17
#define BAROMETER_REG_WHO_AM_I 0x0F
#define BAROMETER_REG_RES_CONF 0x1A
#define BAROMETER_REG_CTRL_REG1 0x10
#define BAROMETER_BFLD_PD (0<<7)
#define BAROMETER_ODR_2 (0<<6)
#define BAROMETER_ODR_1 (0<<5)
#define BAROMETER_ODR_0 (0<<4)
#define BAROMETER_ENABLE_LPFP (0<<3)
#define BAROMETER_LPFP_CFG (0<<2)
#define BAROMETER_BDU (0<<1)
#define BAROMETER_SIM (0<<0)
#define BAROMETER_REG_CTRL_REG2 0x11
#define BAROMETER_BFLD_BOOT (1<<7)
#define BAROMETER_FIFO_ENABLE (0<<6)
#define BAROMETER_STOP_ON_FTH (0<<5)
#define BAROMETER_IF_ADD_INC (1<<4)
#define BAROMETER_I2C_DIS (0<<3)
#define BAROMETER_BFLD_SWRESET (1<<2)
#define BAROMETER_BFLD_ZEROBIT (0<<1)
#define BAROMETER_BFLD_ONE_SHOT (1<<0)
#define BAROMETER_REG_CTRL_REG3 0x12
#define BAROMETER_REG_INTERRUPT_CFG 0x0B
#define BAROMETER_REG_INT_SOURCE 0x25
#define BAROMETER_REG_STATUS_REG 0x27
#define BAROMETER_BFLD_P_DA (1<<0)
#define BAROMETER_BFLD_T_DA (1<<1)
#define BAROMETER_REG_PRESS_OUT_XL 0x28
#define BAROMETER_REG_PRESS_OUT_L 0x29
#define BAROMETER_REG_PRESS_OUT_H 0x2A
#define BAROMETER_REG_TEMP_OUT_L 0x2B
#define BAROMETER_REG_TEMP_OUT_H 0x2C
#define BAROMETER_REG_FIFO_CTRL 0x14
#define BAROMETER_REG_FIFO_STATUS 0x26
#define BAROMETER_REG_THS_P_L 0x0C
#define BAROMETER_REG_THS_P_H 0x0D
#define BAROMETER_REG_RPDS_L 0x18
#define BAROMETER_REG_RPDS_H 0x19
/**
* @brief Hygrometer register defines
*/
#define HYGROMETER_REG_WHO_AM_I 0x0F
#define HYGROMETER_REG_AV_CONF 0x10
#define HYGROMETER_REG_CTRL_REG1 0x20
#define HYGROMETER_BFLD_PD (1<<7)
#define HYGROMETER_REG_CTRL_REG2 0x21
#define HYGROMETER_BFLD_BOOT (1<<7)
#define HYGROMETER_BFLD_ONE_SHOT (1<<0)
#define HYGROMETER_REG_CTRL_REG3 0x22
#define HYGROMETER_REG_STATUS_REG 0x27
#define HYGROMETER_BFLD_H_DA (1<<1)
#define HYGROMETER_BFLD_T_DA (1<<0)
#define HYGROMETER_REG_HUMIDITY_OUT_L 0x28
#define HYGROMETER_REG_HUMIDITY_OUT_H 0x29
#define HYGROMETER_REG_TEMP_OUT_L 0x2A
#define HYGROMETER_REG_TEMP_OUT_H 0x2B
#define HYGROMETER_REG_CALIB_0 0x30 // Convenience define for beginning of calibration registers
#define HYGROMETER_REG_H0_rH_x2 0x30
#define HYGROMETER_REG_H1_rH_x2 0x31
#define HYGROMETER_REG_T0_degC_x8 0x32
#define HYGROMETER_REG_T1_degC_x8 0x33
#define HYGROMETER_REG_T1_T0_MSB 0x35
#define HYGROMETER_REG_H0_T0_OUT_LSB 0x36
#define HYGROMETER_REG_H0_T0_OUT_MSB 0x37
#define HYGROMETER_REG_H1_T0_OUT_LSB 0x3A
#define HYGROMETER_REG_H1_T0_OUT_MSB 0x3B
#define HYGROMETER_REG_T0_OUT_LSB 0x3C
#define HYGROMETER_REG_T0_OUT_MSB 0x3D
#define HYGROMETER_REG_T1_OUT_LSB 0x3E
#define HYGROMETER_REG_T1_OUT_MSB 0x3F
/**
* @brief AXI QSPI Temperature sensor defines
*/
#define PL_SPI_BASEADDR XPAR_AXI_QUAD_SPI_0_BASEADDR // Base address for AXI SPI controller
#define PL_SPI_CHANNEL_SEL_0 0xFFFFFFFE // Select spi channel 0
#define PL_SPI_CHANNEL_SEL_1 0xFFFFFFFD // Select spi channel 1
#define PL_SPI_CHANNEL_SEL_NONE 0xFFFFFFFF // Deselect all SPI channels
// Initialization settings for the AXI SPI controller's Control Register when addressing the MAX31855
// 0x186 = b1_1000_0110
// 1 Inhibited to hold off transactions starting
// 1 Manually select the slave
// 0 Do not reset the receive FIFO at this time
// 0 Do not reset the transmit FIFO at this time
// 0 Clock phase of 0
// 0 Clock polarity of low
// 1 Enable master mode
// 1 Enable the SPI Controller
// 0 Do not put in loopback mode
#define MAX31855_CLOCK_PHASE_CPHA 0
#define MAX31855_CLOCK_POLARITY_CPOL 0
#define MAX31855_CR_INIT_MODE XSP_CR_TRANS_INHIBIT_MASK | XSP_CR_MANUAL_SS_MASK | \
XSP_CR_MASTER_MODE_MASK | XSP_CR_ENABLE_MASK
#define MAX31855_CR_UNINHIBIT_MODE XSP_CR_MANUAL_SS_MASK | \
XSP_CR_MASTER_MODE_MASK | XSP_CR_ENABLE_MASK
#define AXI_SPI_RESET_VALUE 0x0A //!< Reset value for the AXI SPI Controller
/**
* @brief Utility macro to uniformly process errors
*/
#define MAY_DIE(code) \
{ \
code; \
if(pSystem->rc != XST_SUCCESS) { \
pSystem->bError = 1; \
configPRINTF( (pSystem->pcErr, pSystem->rc ) ); \
StopHere(); \
goto L_DIE; \
} \
}
static inline BaseType_t MS_TO_TICKS(BaseType_t xMs)
{
TickType_t xTicks = pdMS_TO_TICKS( xMs );
if(xTicks < 1) {
xTicks = 1;
}
return xTicks;
}
/*-----------------------------------------------------------*/
/**
* @brief System handle contents
*/
#define SYSTEM_SENSOR_TOPIC_LENGTH 64
#define SYSTEM_SHADOW_TOPIC_LENGTH 128
typedef struct System {
XIic iic;
XGpioPs gpio;
MQTTAgentHandle_t xMQTTHandle;
#if UZED_USE_GG
GGD_HostAddressData_t xHostAddressData;
char pcJSONFile[ GG_DISCOVERY_FILE_SIZE ];
#endif
u8 pbHygrometerCalibration[16];
int rc;
const char* pcErr;
uint8_t bError;
uint8_t bLastReportedError;
// Sensor start ok
uint8_t bBarometerOk;
uint8_t bHygrometerOk;
uint8_t bThermocoupleOk;
// Sensor values
float fBarometerPressure;
float fBarometerTemperature;
float fHygrometerHumidity;
float fHygrometerTemperature;
float fThermocoupleTemperature;
float fThermocoupleBoardTemperature;
uint16_t usSensorTopicLength;
uint8_t pbSensorTopic[SYSTEM_SENSOR_TOPIC_LENGTH + 1];
uint16_t usShadowTopicLength;
uint8_t pbShadowTopic[SYSTEM_SHADOW_TOPIC_LENGTH + 1];
} System;
System g_tSystem;
/*-----------------------------------------------------------*/
/**
* @brief Convenience function for breakpoints
*/
static void StopHere(void);
/*-----------------------------------------------------------*/
/**
* @brief Publishes specified messag
*
* @param[in] pSystem System info
* @param[in] pPublishParameters Publication Parameters
*/
static void prvPublish(System* pSystem, MQTTAgentPublishParams_t* pPublishParameters);
/**
* @brief Publishes shadow from system handle
*
* @param[in] pSystem System info
*/
static void prvPublishShadow(System* pSystem);
/**
* @brief Publishes sensors from system handle
*
* @param[in] pSystem System info
*/
static void prvPublishSensors(System* pSystem);
/**
* @brief Creates an MQTT client and then connects to the MQTT broker.
*
* The MQTT broker end point is set by clientcredentialMQTT_BROKER_ENDPOINT.
*
* @return Exit task if failure
*/
static void prvCreateClientAndConnectToBroker( System* pSystem );
/*-----------------------------------------------------------*/
/**
* @brief Starts complete system
*
* @return Exit task if failure
*/
static void StartSystem(System* pSystem);
/**
* @brief Stops complete system
*
* @return Exit task
*/
static void StopSystem(System* pSystem);
/**
* @brief Implements the task that connects to and then publishes messages to the
* MQTT broker.
*
* Messages are published at 2Hz for a minute.
*
* @param[in] pvParameters Parameters passed while creating the task. Unused in our
* case.
*/
static void prvUZedIotTask( void * pvParameters );
/*-----------------------------------------------------------*/
/**
* @brief Blink system LED
*
* @param[in] pSystem System handle
* @param[in] xCount Number of times to blink LED
* @param[in] xFinalOn Should the LED be left on or off at end
*/
static void BlinkLed(System* pSystem,BaseType_t xCount, BaseType_t xFinalOn);
/*-----------------------------------------------------------*/
/**
* @brief Read multiple IIC registers
*
* @param[in] pSystem System handle
* @param[in] bSlaveAddress Slave address on bus
* @param[in] xCount Number of registers to read
* @param[in] bFirstSlaveReg First register number on device
* @param[in] pbBuf Byte buffer to deposit data read from device
*/
static int ReadIicRegs(System* pSystem,u8 bSlaveAddress,BaseType_t xCount,u8 bFirstSlaveReg,u8* pbBuf);
/**
* @brief Read single IIC register
*
* @param[in] pSystem System handle
* @param[in] bSlaveAddress Slave address on bus
* @param[in] bSlaveReg Register number on slave device
* @param[in] pbBuf Byte buffer to deposit data read from device
*/
static int ReadIicReg(System* pSystem,u8 bSlaveAddress,u8 bSlaveReg,u8* pbBuf);
/**
* @brief Write multiple IIC registers
*
* @param[in] pSystem System handle
* @param[in] bSlaveAddress Slave address on bus
* @param[in] xCount Number of registers to write
* @param[in] pbBuf Byte buffer with data to write - >= 2 bytes - first byte is always register number on slave device
*/
static int WriteIicRegs(System* pSystem,u8 bSlaveAddress,BaseType_t xCount,u8* pbBuf);
/**
* @brief Write single IIC register
*
* @param[in] pSystem System handle
* @param[in] bSlaveAddress Slave address on bus
* @param[in] bSlaveReg Register number on slave device
* @param[in] pbBuf Byte buffer with data to write - 2 bytes - first byte is always register number on slave device
*/
static int WriteIicReg(System* pSystem,u8 bSlaveAddress,u8 bSlaveReg,u8 bVal);
/*-----------------------------------------------------------*/
/**
* @brief Start Barometer
*
* @param[in] pSystem System handle
*/
static void StartBarometer(System* pSystem);
/**
* @brief Stop Barometer
*
* @param[in] pSystem System handle
*/
static void StopBarometer(System* pSystem);
/**
* @brief Sample Barometer and publish values
*
* @param[in] pSystem System handle
*/
static void SampleBarometer(System* pSystem);
/*-----------------------------------------------------------*/
/**
* @brief Start Hygrometer
*
* @param[in] pSystem System handle
*/
static void StartHygrometer(System* pSystem);
/**
* @brief Stop Hygrometer
*
* @param[in] pSystem System handle
*/
static void StopHygrometer(System* pSystem);
/**
* @brief Sample Hygrometer and publish values
*
* @param[in] pSystem System handle
*/
static void SampleHygrometer(System* pSystem);
/*-----------------------------------------------------------*/
/**
* @brief Start PL Temperature Sensor
*
* @param[in] pSystem System handle
*/
static void StartPLTempSensor(System* pSystem);
/**
* @brief Stop PL Temperature Sensor
*
* @param[in] pSystem System handle
*/
static void StopPLTempSensor(System* pSystem);
/**
* @brief PL Temperature Sensor: utility function to do SPI transaction
*
* @param[in] pSystem System handle
* @param[in] qBaseAddress AXI SPI Controller Base Address
* @param[in] xSPI_Channel SPI Channel to use
* @param[in] xByteCount Number of bytes to transfer
* @param[in] pqTxBuffer Data to send
* @param[out] pqRxBuffer Data to receive
*/
static void XSpi_LowLevelExecute(System* pSystem, u32 qBaseAddress, BaseType_t xSPI_Channel, BaseType_t xByteCount, const u32* pqTxBuffer, u32* pqRxBuffer);
/**
* @brief Sample Barometer and publish values
*
* @param[in] pSystem System handle
*/
static void SamplePLTempSensor(System* pSystem);
/*--------------------------------------------------------------------------------*/
static void StopHere(void)
{
;
}
/*--------------------------------------------------------------------------------*/
static void BlinkLed(System* pSystem,BaseType_t xCount, BaseType_t xFinalOn)
{
BaseType_t x;
const TickType_t xHalfSecond = MS_TO_TICKS( 500 );
if(!pSystem->gpio.IsReady) {
return;
}
for(x = 0; x < xCount; x++) {
XGpioPs_WritePin(&pSystem->gpio, LED_PIN, 1);
vTaskDelay(xHalfSecond);
XGpioPs_WritePin(&pSystem->gpio, LED_PIN, 0);
vTaskDelay(xHalfSecond);
}
if(xFinalOn) {
XGpioPs_WritePin(&pSystem->gpio, LED_PIN, 1);
}
}
/*-----------------------------------------------------------*/
static void prvPublish(System* pSystem, MQTTAgentPublishParams_t* pPublishParameters)
{
MQTTAgentReturnCode_t xReturned;
if(!pPublishParameters->usTopicLength) {
pPublishParameters->usTopicLength = strlen((const char*)pPublishParameters->pucTopic);
if(!pPublishParameters->usTopicLength) {
return;
}
}
if(!pPublishParameters->ulDataLength) {
pPublishParameters->ulDataLength = strlen((const char*)pPublishParameters->pvData);
if(!pPublishParameters->ulDataLength) {
return;
}
}
/* Publish the message. */
xReturned = MQTT_AGENT_Publish( pSystem->xMQTTHandle, pPublishParameters, democonfigMQTT_TIMEOUT );
switch(xReturned) {
case eMQTTAgentSuccess:
configPRINTF( ( "Success: Published '%s'\r\n", (const char*)pPublishParameters->pucTopic, (const char*)pPublishParameters->pvData ) );
break;
case eMQTTAgentFailure:
BlinkLed(pSystem, 1, pdFALSE);
configPRINTF( ( "ERROR: Failed to publish '%s'\r\n", (const char*)pPublishParameters->pucTopic, (const char*)pPublishParameters->pvData ) );
break;
case eMQTTAgentTimeout:
BlinkLed(pSystem, 1, pdFALSE);
configPRINTF( ( "ERROR: Timed out publishing '%s'\r\n", (const char*)pPublishParameters->pucTopic, (const char*)pPublishParameters->pvData ) );
break;
default: //FallThrough
case eMQTTAgentAPICalledFromCallback:
BlinkLed(pSystem, 1, pdFALSE);
configPRINTF( ( "ERROR: Unexpected callback publishing '%s'\r\n", (const char*)pPublishParameters->pucTopic, (const char*)pPublishParameters->pvData ) );
configASSERT(pdTRUE);
break; // Not reached
}
}
static void prvPublishShadow(System* pSystem)
{
MQTTAgentPublishParams_t xPublishParameters;
char pcDataBuffer[ UZedMAX_DATA_LENGTH ];
int iDataLength;
if(pSystem->xMQTTHandle == NULL) {
return;
}
/*
* Compose the message
*/
iDataLength = snprintf(pcDataBuffer, UZedMAX_DATA_LENGTH, "{\"state\": { \"desired\": {\"led\":%u}}}", pSystem->bError);
pcDataBuffer[UZedMAX_DATA_LENGTH - 1] = 0; // safety
if(iDataLength >= UZedMAX_DATA_LENGTH) {
iDataLength = UZedMAX_DATA_LENGTH - 1;
} else if(iDataLength < 0) {
iDataLength = 3;
pcDataBuffer[0] = '?';
pcDataBuffer[1] = '?';
pcDataBuffer[2] = '?';
pcDataBuffer[3] = '\0';
}
/* Setup the publish parameters. */
memset( &( xPublishParameters ), 0, sizeof( xPublishParameters ) );
xPublishParameters.pucTopic = (const uint8_t*)pSystem->pbShadowTopic;
xPublishParameters.usTopicLength = pSystem->usShadowTopicLength;
xPublishParameters.xQoS = eMQTTQoS0;
xPublishParameters.pvData = (void*)pcDataBuffer;
xPublishParameters.ulDataLength = ( uint32_t ) iDataLength;
prvPublish(pSystem,&xPublishParameters);
}
static void prvPublishSensors(System* pSystem)
{
MQTTAgentPublishParams_t xPublishParameters;
char pcDataBuffer[ UZedMAX_DATA_LENGTH ];
int iDataLength;
if(pSystem->xMQTTHandle == NULL) {
return;
}
/*
* Compose the message
*/
iDataLength = snprintf(pcDataBuffer, UZedMAX_DATA_LENGTH,
"{\n "
"\"%s\": %.2f,\n"
"\"%s\": %.2f,\n"
"\"%s\": %.2f,\n"
"\"%s\": %.2f,\n"
"\"%s\": %.2f,\n"
"\"%s\": %.2f\n"
"}"
,
"Pressure", pSystem->fBarometerPressure,
"Pressure_Sensor_Temp", pSystem->fBarometerTemperature,
"Thermocouple_Temp", pSystem->fThermocoupleTemperature,
"Board_Temp_1", pSystem->fThermocoupleBoardTemperature,
"Relative_Humidity", pSystem->fHygrometerHumidity,
"Humidity_Sensor_Temp", pSystem->fHygrometerTemperature
);
pcDataBuffer[UZedMAX_DATA_LENGTH - 1] = 0; // safety
if((iDataLength < 0) || (iDataLength >= UZedMAX_DATA_LENGTH)) {
pSystem->bError = 1;
return;
}
/* Setup the publish parameters. */
memset( &( xPublishParameters ), 0, sizeof( xPublishParameters ) );
xPublishParameters.pucTopic = pSystem->pbSensorTopic;
xPublishParameters.usTopicLength = pSystem->usSensorTopicLength;
xPublishParameters.xQoS = eMQTTQoS0;
xPublishParameters.pvData = (void*)pcDataBuffer;
xPublishParameters.ulDataLength = ( uint32_t ) iDataLength;
prvPublish(pSystem,&xPublishParameters);
}
/*--------------------------------------------------------------------------------*/
static void prvCreateClientAndConnectToBroker( System* pSystem )
{
MQTTAgentConnectParams_t xConnectParameters;
BaseType_t xStatus;
configPRINTF( ( "Broker ID: '%s'\r\n", clientcredentialMQTT_BROKER_ENDPOINT ) );
/* The MQTT client object must be created before it can be used. The
* maximum number of MQTT client objects that can exist simultaneously
* is set by mqttconfigMAX_BROKERS. */
if( eMQTTAgentSuccess == MQTT_AGENT_Create( &pSystem->xMQTTHandle ) ) {
#if UZED_USE_GG
configPRINTF( ( "Attempting automated selection of Greengrass device\r\n" ) );
memset( &pSystem->xHostAddressData, 0, sizeof( GGD_HostAddressData_t ) );
xStatus = GGD_GetGGCIPandCertificate(pSystem->pcJSONFile,GG_DISCOVERY_FILE_SIZE,&pSystem->xHostAddressData);
if(pdPASS == xStatus) {
configPRINTF( ("Success: GGC is %s\r\n", pSystem->xHostAddressData.pcHostAddress ) );
xConnectParameters.pcURL = pSystem->xHostAddressData.pcHostAddress;
xConnectParameters.xFlags = mqttagentREQUIRE_TLS | mqttagentURL_IS_IP_ADDRESS;
xConnectParameters.xURLIsIPAddress = pdTRUE; /* Deprecated. */
xConnectParameters.usPort = clientcredentialMQTT_BROKER_PORT;
xConnectParameters.pucClientId = (const uint8_t*)clientcredentialIOT_THING_NAME;
xConnectParameters.usClientIdLength = (uint16_t)strlen(clientcredentialIOT_THING_NAME);
xConnectParameters.xSecuredConnection = pdTRUE; /* Deprecated. */
xConnectParameters.pvUserData = NULL;
xConnectParameters.pxCallback = NULL;
xConnectParameters.pcCertificate = pSystem->xHostAddressData.pcCertificate;
xConnectParameters.ulCertificateSize = pSystem->xHostAddressData.ulCertificateSize;
} else {
configPRINTF( ("Failed: GGD_GetGGCIPandCertificate()\n" ) );
xConnectParameters.pcURL = 0;
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Auto-connect: Failed to retrieve Greengrass address and certificate\r\n";
pSystem->xMQTTHandle = NULL;
}
#else
/* Connect directly to the broker. */
xConnectParameters.pcURL = clientcredentialMQTT_BROKER_ENDPOINT; /* The URL of the MQTT broker to connect to. */
xConnectParameters.xFlags = democonfigMQTT_AGENT_CONNECT_FLAGS; /* Connection flags. */
xConnectParameters.xURLIsIPAddress = pdFALSE; /* Deprecated. */
xConnectParameters.usPort = clientcredentialMQTT_BROKER_PORT; /* Port number on which the MQTT broker is listening. Can be overridden by ALPN connection flag. */
xConnectParameters.pucClientId = UZedCLIENT_ID; /* Client Identifier of the MQTT client. It should be unique per broker. */
xConnectParameters.usClientIdLength = (uint16_t)strlen((const char*)UZedCLIENT_ID);
xConnectParameters.xSecuredConnection = pdFALSE; /* Deprecated. */
xConnectParameters.pvUserData = NULL; /* User data supplied to the callback. Can be NULL. */
xConnectParameters.pxCallback = NULL; /* Callback used to report various events. Can be NULL. */
xConnectParameters.pcCertificate = NULL; /* Certificate used for secure connection. Can be NULL. */
xConnectParameters.ulCertificateSize = 0; /* Size of certificate used for secure connection. */
#endif
if(xConnectParameters.pcURL) {
configPRINTF( ( "INFO: %s: Attempting to connect to '%s'\r\n",
UZED_USE_GG? "GreenGrass":"MQTT",
xConnectParameters.pcURL ) );
if(eMQTTAgentSuccess == MQTT_AGENT_Connect(
pSystem->xMQTTHandle,
&xConnectParameters,
democonfigMQTT_UZED_TLS_NEGOTIATION_TIMEOUT
)
) {
configPRINTF( ( "SUCCESS: connected\r\n" ) );
pSystem->rc = XST_SUCCESS;
} else {
/* Could not connect, so delete the MQTT client. */
( void ) MQTT_AGENT_Delete( pSystem->xMQTTHandle );
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "ERROR: Could not connect\r\n";
pSystem->xMQTTHandle = NULL;
configPRINTF( ( "%s\r\n", pSystem->pcErr ) );
}
}
} else {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "ERROR: Could not create MQTT Agent\r\n";
pSystem->xMQTTHandle = NULL;
configPRINTF( ( "%s\r\n", pSystem->pcErr ) );
}
}
/*--------------------------------------------------------------------------------*/
static int ReadIicRegs(System* pSystem,u8 bSlaveAddress,BaseType_t xCount,u8 bFirstSlaveReg,u8* pbBuf)
{
BaseType_t xReceived;
if(xCount > 1) {
bFirstSlaveReg |= 0x80;
}
MAY_DIE({
if(1 != XIic_Send(pSystem->iic.BaseAddress,bSlaveAddress,&bFirstSlaveReg,1,XIIC_REPEATED_START)) {
pSystem->rc = 1;
pSystem->pcErr = "ReadIicRegs::XIic_Send(Addr) -> 0x%08x\r\n";
}
});
MAY_DIE({
xReceived = XIic_Recv(pSystem->iic.BaseAddress,bSlaveAddress,pbBuf,xCount,XIIC_STOP);
if(xReceived != xCount) {
pSystem->rc = ((xReceived & 0xf) << 4) | (xCount & 0xf);
pSystem->pcErr = "ReadIicRegs::XIic_Recv(Data) -> 0x%08x\r\n";
}
});
L_DIE:
return pSystem->rc;
}
static int ReadIicReg(System* pSystem, u8 bSlaveAddress, u8 bFirstSlaveReg, u8* pbBuf)
{
return ReadIicRegs(pSystem, bSlaveAddress, 1, bFirstSlaveReg, pbBuf);
}
static int WriteIicRegs(System* pSystem, u8 bSlaveAddress, BaseType_t xCount, u8* pbBuf)
{
BaseType_t xSent;
if(xCount > 2) {
pbBuf[0] |= 0x80;
}
MAY_DIE({
xSent = XIic_Send(pSystem->iic.BaseAddress,bSlaveAddress,pbBuf,xCount,XIIC_STOP);
if(xCount != xSent) {
pSystem->rc = ((xSent & 0xf) << 4) | (xCount & 0xf);
pSystem->pcErr = "WriteIicRegs::XIic_Send(Buf) -> 0x%08x\r\n";
}
});
L_DIE:
return pSystem->rc;
}
static int WriteIicReg(System* pSystem,u8 bSlaveAddress, u8 bFirstSlaveReg, u8 bVal)
{
u8 pbBuf[2];
pbBuf[0] = bFirstSlaveReg;
pbBuf[1] = bVal;
return WriteIicRegs(pSystem, bSlaveAddress, 2, pbBuf);
}
/*--------------------------------------------------------------------------------*/
static void StartBarometer(System* pSystem)
{
u8 b;
int iTimeout;
TickType_t xOneMs = MS_TO_TICKS( 1 );
pSystem->bBarometerOk = pdFALSE;
pSystem->fBarometerPressure = 0;
pSystem->fBarometerTemperature = 0;
// Verify it is the right chip
MAY_DIE({
ReadIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_WHO_AM_I,&b);
pSystem->pcErr = "ReadIicReg(WHO_AM_I) -> 0x%08x\r\n";
});
MAY_DIE({
if(0xB1 != b) {
pSystem->rc = b?b:1;
pSystem->pcErr = "BAROMETER_WHO_AM_I = 0x%08x != 0xB1\r\n";
}
});
// Reset chip: first swreset, then boot
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_BFLD_SWRESET);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BFLD_SWRESET) -> 0x%08x\r\n";
});
for(iTimeout = 100; iTimeout-- > 0; ) {
MAY_DIE({
ReadIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,&b);
pSystem->pcErr = "ReadIicReg(BAROMETER_REG_CTRL_REG2) -> 0x%08x\r\n";
});
if(0 == (b & BAROMETER_BFLD_SWRESET)) {
break;
}
vTaskDelay(xOneMs);
}
if(iTimeout <= 0) {
MAY_DIE({
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Barometer swreset timeout\r\n";
});
}
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_BFLD_BOOT);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_BFLD_BOOT -> 0x%08x\r\n";
});
for(iTimeout = 100; iTimeout-- > 0; ) {
MAY_DIE({
ReadIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,&b);
pSystem->pcErr = "ReadIicReg(BAROMETER_REG_CTRL_REG2) -> 0x%08x\r\n";
});
if(0 == (b & BAROMETER_BFLD_BOOT)) {
break;
}
vTaskDelay(xOneMs);
}
if(iTimeout <= 0) {
MAY_DIE({
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Barometer boot timeout\r\n";
});
}
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_BFLD_ZEROBIT);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_BFLD_ZEROBIT -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_FIFO_ENABLE);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_FIFO_ENABLE -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_STOP_ON_FTH);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_STOP_ON_FTH -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_IF_ADD_INC);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_IF_ADD_INC -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2, BAROMETER_I2C_DIS);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_I2C_DIS) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_ODR_2);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_ODR_2) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_ODR_1);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_ODR_1) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_ODR_0);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_ODR_0) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_ENABLE_LPFP);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_ENABLE_LPFP) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_LPFP_CFG);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_LPFP_CFG) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_BDU);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_BDU) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_SIM);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_SIM) -> 0x%08x\r\n";
});
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG1,BAROMETER_BFLD_PD);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG1::BAROMETER_BFLD_PD) -> 0x%08x\r\n";
});
vTaskDelay(xOneMs);
pSystem->bBarometerOk = pdTRUE;
configPRINTF( ( "Barometer started ok\r\n" ) );
return;
L_DIE:
configPRINTF( ( "ERROR: Barometer started not ok\r\n" ) );
return;
}
static void StopBarometer(System* pSystem)
{
pSystem->bBarometerOk = pdFALSE;
}
static void SampleBarometer(System* pSystem)
{
BaseType_t xTimeout;
u8 b;
u8 pbBuf[6];
s32 sqTmp;
float f;
u8 count = 0;
TickType_t xOneMs = MS_TO_TICKS( 1 );
if(!pSystem->bBarometerOk) {
return;
}
pSystem->rc = XST_SUCCESS;
/*
* NOTE: The one shot auto clears but it seems to take 36ms
* Our sampling period is >= 100ms so the one shot will auto clear by the next sample time
*/
MAY_DIE({
WriteIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,BAROMETER_BFLD_ONE_SHOT);
pSystem->pcErr = "WriteIicReg(BAROMETER_REG_CTRL_REG2::BAROMETER_BFLD_ONE_SHOT) -> 0x%08x\r\n";
});
for(xTimeout = 50; xTimeout-- > 0; ) {
MAY_DIE({
ReadIicReg(pSystem,BAROMETER_SLAVE_ADDRESS,BAROMETER_REG_CTRL_REG2,&b);
pSystem->pcErr = "ReadIicReg(BAROMETER_REG_CTRL_REG2) -> 0x%08x\r\n";
});
if(0 == (b & BAROMETER_BFLD_ONE_SHOT)) {
break;
}
vTaskDelay(xOneMs);
}
MAY_DIE({
if(xTimeout <= 0) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Timed out waiting for BAROMETER_BFLD_ONE_SHOT\r\n";
}
});
for(xTimeout = 50; xTimeout-- > 0; ) {
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,6,BAROMETER_REG_STATUS_REG,pbBuf);
pSystem->pcErr = "ReadIicRegs(6@BAROMETER_REG_STATUS_REG) -> 0x%08x\r\n";
});
if((BAROMETER_BFLD_P_DA | BAROMETER_BFLD_T_DA) == (pbBuf[0] & (BAROMETER_BFLD_P_DA | BAROMETER_BFLD_T_DA))) {
break;
}
vTaskDelay(xOneMs);
}
MAY_DIE({
if(xTimeout <= 0) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Timed out waiting for P_DA and T_DA\r\n";
}
});
for(count=1; count<6;count++)
pbBuf[count] = 0;
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,1,BAROMETER_REG_PRESS_OUT_XL,&pbBuf[1]);
pSystem->pcErr = "ReadIicRegs(BAROMETER_REG_PRESS_OUT_XL) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,1,BAROMETER_REG_PRESS_OUT_L,&pbBuf[2]);
pSystem->pcErr = "ReadIicRegs(BAROMETER_REG_PRESS_OUT_L) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,1,BAROMETER_REG_PRESS_OUT_H,&pbBuf[3]);
pSystem->pcErr = "ReadIicRegs(BAROMETER_REG_PRESS_OUT_H) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,1,BAROMETER_REG_TEMP_OUT_L,&pbBuf[4]);
pSystem->pcErr = "ReadIicRegs(BAROMETER_REG_TEMP_OUT_L) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicRegs(pSystem,BAROMETER_SLAVE_ADDRESS,1,BAROMETER_REG_TEMP_OUT_H,&pbBuf[5]);
pSystem->pcErr = "ReadIicRegs(BAROMETER_REG_TEMP_OUT_H) -> 0x%08x\r\n";
});
// See ST TN1228
sqTmp = 0
| ((u32)pbBuf[1] << 0) // xl
| ((u32)pbBuf[2] << 8) // l
| ((u32)pbBuf[3] << 16) // h
;
if(sqTmp & 0x00800000) {
sqTmp |= 0xFF800000;
}
f = (float)sqTmp / 4096.0F;
pSystem->fBarometerPressure = f;
sqTmp = 0
| ((u32)pbBuf[4] << 0) // l
| ((u32)pbBuf[5] << 8) // h
;
if(sqTmp & 0x00008000) {
sqTmp |= 0xFFFF8000;
}
f = (float)sqTmp/100.0;
pSystem->fBarometerTemperature = f;
L_DIE:
return;
}
/*--------------------------------------------------------------------------------*/
static void StartHygrometer(System* pSystem)
{
u8 b;
int iTimeout;
TickType_t xOneMs = MS_TO_TICKS( 1 );
pSystem->bHygrometerOk = pdFALSE;
pSystem->fHygrometerHumidity = 0;
pSystem->fHygrometerTemperature = 0;
// Verify it is the right chip
MAY_DIE({
ReadIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_WHO_AM_I,&b);
pSystem->pcErr = "ReadIicReg(HYGROMETER_WHO_AM_I) -> 0x%08x\r\n";
});
MAY_DIE({
if(0xBC != b) {
pSystem->rc = b?b:1;
pSystem->pcErr = "HYGROMETER_WHO_AM_I = 0x%08x != BC\r\n";
}
});
// Reset chip: boot
MAY_DIE({
WriteIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_CTRL_REG2,HYGROMETER_BFLD_BOOT);
pSystem->pcErr = "WriteIicReg(HYGROMETER_REG_CTRL_REG2::HYGROMETER_BFLD_BOOT -> 0x%08x\r\n";
});
for(iTimeout = 1000; iTimeout-- > 0; ) {
MAY_DIE({
ReadIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_CTRL_REG2,&b);
pSystem->pcErr = "ReadIicReg(BAROMETER_REG_CTRL_REG2) -> 0x%08x\r\n";
});
if(0 == (b & HYGROMETER_BFLD_BOOT)) {
break;
}
vTaskDelay(xOneMs);
}
if(iTimeout <= 0) {
MAY_DIE({
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Hygrometer boot timeout\r\n";
});
}
/*
* Read and store calibration values
*/
MAY_DIE({
ReadIicRegs(pSystem,HYGROMETER_SLAVE_ADDRESS,16,HYGROMETER_REG_CALIB_0,&pSystem->pbHygrometerCalibration[0]);
pSystem->pcErr = "ReadIicRegs(HYGROMETER_REG_CALIB_0) -> 0x%08x\r\n";
});
/*
* Power up device
*/
MAY_DIE({
WriteIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_CTRL_REG1,HYGROMETER_BFLD_PD);
pSystem->pcErr = "WriteIicReg(HYGROMETER_REG_CTRL_REG1::HYGROMETER_BFLD_PD) -> 0x%08x\r\n";
});
vTaskDelay(xOneMs);
pSystem->bHygrometerOk = pdTRUE;
configPRINTF( ( "Hygrometer started ok\r\n" ) );
return;
L_DIE:
configPRINTF( ( "ERROR: Hygrometer started not ok\r\n" ) );
return;
}
static void StopHygrometer(System* pSystem)
{
pSystem->bHygrometerOk = pdFALSE;
}
static void SampleHygrometer(System* pSystem)
{
BaseType_t xTimeout;
u8 b;
u8 pbBuf[5];
int H0_T0_out, H1_T0_out, H_T_out;
int H0_rh, H1_rh;
u8 buffer[2];
int tmp = 0;
u16 value = 0;
int T0_out, T1_out, T_out, T0_degC_x8_u16, T1_degC_x8_u16;
int T0_degC, T1_degC;
u8 buff2[4], tmp5 = 0;
int tmp32 = 0;
TickType_t xOneMs = MS_TO_TICKS( 1 );
if(!pSystem->bHygrometerOk) {
return;
}
pSystem->rc = XST_SUCCESS;
/*
* NOTE: The one shot auto clears but it seems to take FIXME ms
* Our sampling period is >= 100ms so the one shot will auto clear by the next sample time??? FIXME
*/
MAY_DIE({
WriteIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_CTRL_REG2,HYGROMETER_BFLD_ONE_SHOT);
pSystem->pcErr = "WriteIicReg(HYGROMETER_REG_CTRL_REG2::HYGROMETER_BFLD_ONE_SHOT) -> 0x%08x\r\n";
});
for(xTimeout = 10000; xTimeout-- > 0; ) {
MAY_DIE({
ReadIicReg(pSystem,HYGROMETER_SLAVE_ADDRESS,HYGROMETER_REG_CTRL_REG2,&b);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_CTRL_REG2) -> 0x%08x\r\n";
});
if(0 == (b & HYGROMETER_BFLD_ONE_SHOT)) {
break;
}
vTaskDelay(xOneMs);
}
MAY_DIE({
if(xTimeout <= 0) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Timed out waiting for HYGROMETER_BFLD_ONE_SHOT\r\n";
}
});
for(xTimeout = 50; xTimeout-- > 0; ) {
MAY_DIE({
ReadIicRegs(pSystem,HYGROMETER_SLAVE_ADDRESS,5,HYGROMETER_REG_STATUS_REG,pbBuf);
pSystem->pcErr = "ReadIicRegs(6@HYGROMETER_REG_STATUS_REG) -> 0x%08x\r\n";
});
if((HYGROMETER_BFLD_H_DA | HYGROMETER_BFLD_T_DA) == (pbBuf[0] & (HYGROMETER_BFLD_H_DA | HYGROMETER_BFLD_T_DA))) {
break;
}
vTaskDelay(xOneMs);
}
MAY_DIE({
if(xTimeout <= 0) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Timed out waiting for HYGROMETER P_DA and T_DA\r\n";
}
});
/*
* REF: ST TN1218
* Interpreting humidity and temperature readings in the HTS221 digital humidity sensor
*/
buffer[0] = 0;
buffer[1] = 0;
/* 1. Read H0_rH and H1_rH coefficients */
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H0_rH_x2 , &buffer[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H0_rH_x2) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H1_rH_x2, &buffer[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H1_rH_x2) -> 0x%08x\r\n";
});
H0_rh = buffer[0]>>1;
H1_rh = buffer[1]>>1;
buffer[0] = 0; buffer[1] = 0;
/*2. Read H0_T0_OUT */
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H0_T0_OUT_LSB, &buffer[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H0_T0_OUT_LSB) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H0_T0_OUT_MSB, &buffer[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H0_T0_OUT_MSB -> 0x%08x\r\n";
});
H0_T0_out = (((u16)buffer[1])<<8) | (u16)buffer[0];
buffer[0] = 0; buffer[1] = 0;
/*3. Read H1_T0_OUT */
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H1_T0_OUT_LSB, &buffer[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H1_T0_OUT_LSB) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_H1_T0_OUT_MSB, &buffer[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_H1_T0_OUT_MSB) -> 0x%08x\r\n";
});
H1_T0_out = (((u16)buffer[1])<<8) | (u16)buffer[0];
buffer[0] = 0; buffer[1] = 0;
/*4. Read H_T_OUT */
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_HUMIDITY_OUT_L, &buffer[0]);
pSystem->pcErr = "ReadIicReg( HYGROMETER_REG_HUMIDITY_OUT_L) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_HUMIDITY_OUT_H, &buffer[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_HUMIDITY_OUT_H -> 0x%08x\r\n";
});
H_T_out = (((u16)buffer[1])<<8) | (u16)buffer[0];
/*5. Compute the RH [%] value by linear interpolation */
value = 0;
tmp = ((int)(H_T_out - H0_T0_out)) * ((int)(H1_rh - H0_rh));
value = (u16) ((tmp/(H1_T0_out - H0_T0_out))+ H0_rh) ;
/* Saturation condition*/
if(value>1000) value = 1000;
pSystem->fHygrometerHumidity = value;
/**
* @brief Read HTS221 temperature output registers, and calculate temperature.
* @param Pointer to the returned temperature value that must be divided by 10 to get the value in ['C].
* @retval Error code [HTS221_OK, HTS221_ERROR].
*/
tmp5 = 0; value = 0;
buff2[0] = 0; buff2[1] = 0; buff2[2] = 0; buff2[3] = 0;
/*1. Read from 0x32 & 0x33 registers the value of coefficients T0_degC_x8 and T1_degC_x8*/
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T0_degC_x8, &buff2[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T0_degC_x8) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T1_degC_x8, &buff2[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T1_degC_x8) -> 0x%08x\r\n";
});
/*2. Read from 0x35 register the value of the MSB bits of T1_degC and T0_degC */
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T1_T0_MSB, &tmp5);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T1_T0_MSB) -> 0x%08x\r\n";
});
/*Calculate the T0_degC and T1_degC values*/
T0_degC_x8_u16 = (((u16)(tmp5 & 0x03)) << 8) | ((u16)buff2[0]);
T1_degC_x8_u16 = (((u16)(tmp5 & 0x0C)) << 6) | ((u16)buff2[1]);
T0_degC = T0_degC_x8_u16>>3;
T1_degC = T1_degC_x8_u16>>3;
/*3. Read from 0x3C & 0x3D registers the value of T0_OUT*/
/*4. Read from 0x3E & 0x3F registers the value of T1_OUT*/
buff2[0] = 0;
buff2[1] = 0;
buff2[2] = 0;
buff2[3] = 0;
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T0_OUT_LSB, &buff2[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T0_OUT_LSB) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T0_OUT_MSB, &buff2[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T0_OUT_LSB) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T1_OUT_LSB, &buff2[2]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T1_OUT_LSB) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_T1_OUT_MSB, &buff2[3]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_T1_OUT_MSB) -> 0x%08x\r\n";
});
T0_out = (((u16)buff2[1])<<8) | (u16)buff2[0];
T1_out = (((u16)buff2[3])<<8) | (u16)buff2[2];
/* 5.Read from 0x2A & 0x2B registers the value T_OUT (ADC_OUT).*/
buff2[0] = 0; buff2[1] = 0; buff2[2] = 0; buff2[3] = 0;
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_TEMP_OUT_L, &buff2[0]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_TEMP_OUT_L) -> 0x%08x\r\n";
});
MAY_DIE({
ReadIicReg(pSystem, HYGROMETER_SLAVE_ADDRESS, HYGROMETER_REG_TEMP_OUT_H, &buff2[1]);
pSystem->pcErr = "ReadIicReg(HYGROMETER_REG_TEMP_OUT_H) -> 0x%08x\r\n";
});
T_out = (((u16)buff2[1])<<8) | (u16)buff2[0];
/* 6. Compute the Temperature value by linear interpolation*/
value = 0;
tmp32 = (( int)(T_out - T0_out)) * (( int)(T1_degC - T0_degC));
value = (tmp32 /(T1_out - T0_out)) + T0_degC;
pSystem->fHygrometerTemperature = value;
L_DIE:
return;
}
/*--------------------------------------------------------------------------------*/
static void StartPLTempSensor(System* pSystem)
{
const TickType_t xOneMs = MS_TO_TICKS(1);
pSystem->bThermocoupleOk = pdFALSE;
pSystem->fThermocoupleBoardTemperature = 0;
pSystem->fThermocoupleTemperature = 0;
//Reset the SPI Peripheral, which takes 4 cycles, so wait a bit after reset
XSpi_WriteReg(PL_SPI_BASEADDR, XSP_SRR_OFFSET, AXI_SPI_RESET_VALUE);
vTaskDelay(xOneMs); //usleep(100);
// Initialize the AXI SPI Controller with settings compatible with the MAX31855
XSpi_WriteReg(PL_SPI_BASEADDR, XSP_CR_OFFSET, MAX31855_CR_INIT_MODE);
// Deselect all slaves to start, then wait a bit for it to take affect
XSpi_WriteReg(PL_SPI_BASEADDR, XSP_SSR_OFFSET, PL_SPI_CHANNEL_SEL_NONE);
vTaskDelay(xOneMs); //usleep(100);
pSystem->bThermocoupleOk = pdTRUE;
configPRINTF( ("PL Thermocouple started - check state after first reading\r\n") );
}
static void StopPLTempSensor(System* pSystem)
{
pSystem->bThermocoupleOk = pdFALSE;
}
static void XSpi_LowLevelExecute(System* pSystem, u32 qBaseAddress, BaseType_t xSPI_Channel, BaseType_t xByteCount, const u32* pqTxBuffer, u32* pqRxBuffer)
{
BaseType_t xNumBytesRcvd = 0;
BaseType_t xCount;
const TickType_t xOneMs = MS_TO_TICKS(1);
/*
* Initialize the Tx FIFO in the AXI SPI Controller with the transmit
* data contained in TxBuffer
*/
for (xCount = 0; xCount < xByteCount; pqTxBuffer++, xCount++)
{
XSpi_WriteReg(qBaseAddress, XSP_DTR_OFFSET, *pqTxBuffer);
}
// Assert the Slave Select, then wait a bit so it takes affect
XSpi_WriteReg(qBaseAddress, XSP_SSR_OFFSET, xSPI_Channel);
vTaskDelay(xOneMs); //usleep(100);
/*
* Disable the Inhibit bit in the AXI SPI Controller's controler register
* This will release the AXI SPI Controller to release the transaction onto the bus
*/
XSpi_WriteReg(qBaseAddress, XSP_CR_OFFSET, MAX31855_CR_UNINHIBIT_MODE);
/*
* Wait for the AXI SPI controller's transmit FIFO to transition to empty
* to make sure all the transmit data gets sent
*/
while (!(XSpi_ReadReg(qBaseAddress, XSP_SR_OFFSET) & XSP_SR_TX_EMPTY_MASK));
/*
* Wait for the AXI SPI controller's Receive FIFO Occupancy register to
* show the expected number of receive bytes before attempting to read
* the Rx FIFO. Note the Occupancy Register shows Rx Bytes - 1
*
* If xByteCount number of bytes is sent, then by design, there must be
* xByteCount number of bytes received
*/
xByteCount--;
while(xByteCount != XSpi_ReadReg(qBaseAddress, XSP_RFO_OFFSET)) {
;
}
xByteCount++;
/*
* The AXI SPI Controller's Rx FIFO has now received TxByteCount number
* of bytes off the SPI bus and is ready to be read.
*
* Transfer the Rx bytes out of the Controller's Rx FIFO into our code
* Keep reading one byte at a time until the Rx FIFO is empty
*/
xNumBytesRcvd = 0;
while ((XSpi_ReadReg(qBaseAddress, XSP_SR_OFFSET) & XSP_SR_RX_EMPTY_MASK) == 0)
{
*pqRxBuffer++ = XSpi_ReadReg(qBaseAddress, XSP_DRR_OFFSET);
xNumBytesRcvd++;
}
// Now that the Rx Data is retrieved, inhibit the AXI SPI Controller
XSpi_WriteReg(qBaseAddress, XSP_CR_OFFSET, MAX31855_CR_INIT_MODE);
// Deassert the Slave Select
XSpi_WriteReg(qBaseAddress, XSP_SSR_OFFSET, PL_SPI_CHANNEL_SEL_NONE);
/*
* If no data was sent or if we didn't receive as many bytes as
* were transmitted, then flag a failure
*/
if (xByteCount != xNumBytesRcvd) {
pSystem->rc = ((xByteCount & 0xf) << 4) | (xNumBytesRcvd & 0xf);
pSystem->pcErr = "XSpi_LowLevelExecute() -> 0x%08x\r\n";
return;
}
pSystem->rc = XST_SUCCESS;
return;
}
/**
* @brief Sample Barometer and publish values
*
* @param[in] pSystem System handle
*/
static void SamplePLTempSensor(System* pSystem)
{
// TxBuffer is not used to communicate with the MAX31855 but it is still necessary
// for the XSPI utilities to function
u32 pqTxBuffer[4] = {0,0,0,0};
u32 pqRxBuffer[4] = {~0,~0,~0,~0}; // Initialize RxBuffer with all 1's
s32 sqTemporaryValue = 0;
s32 sqTemporaryValue2 = 0;
float fMAX31855_internal_temp = 0.0f;
float fMAX31855_thermocouple_temp = 0.0f;
if(!pSystem->bThermocoupleOk) {
return;
}
pSystem->rc = XST_SUCCESS;
// Execute 4-byte read transaction.
MAY_DIE({
XSpi_LowLevelExecute(pSystem, (u32)PL_SPI_BASEADDR, (BaseType_t)PL_SPI_CHANNEL_SEL_0, (BaseType_t)4, pqTxBuffer, pqRxBuffer );
if(XST_SUCCESS == pSystem->rc) {
if(0) {
;
} else if(pqRxBuffer[3] & 0x1) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Thermocouple: Open Circuit\r\n";
} else if(pqRxBuffer[3] & 0x2) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Thermocouple: Short to GND\r\n";
} else if(pqRxBuffer[3] & 0x4) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Thermocouple: Short to VCC\r\n";
} else if(pqRxBuffer[1] & 0x01) {
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Thermocouple: Fault\r\n";
}
}
});
// Internal Temp
{
sqTemporaryValue = pqRxBuffer[2]; // bits 11..4
sqTemporaryValue = sqTemporaryValue << 4; // shift left to make room for bits 3..0
sqTemporaryValue2 = pqRxBuffer[3]; // bits 3..0 in the most significant spots
sqTemporaryValue2 = sqTemporaryValue2 >> 4; // shift right to get rid of extra bits and position
sqTemporaryValue |= sqTemporaryValue2; // Combine to get bits 11..0
if((pqRxBuffer[2] & 0x80) == 0x80) { // Check the sign bit and sign-extend if need be
sqTemporaryValue |= 0xFFFFF800;
}
fMAX31855_internal_temp = (float)sqTemporaryValue / 16.0f;
pSystem->fThermocoupleBoardTemperature = fMAX31855_internal_temp;
}
// Thermocouple Temp
{
sqTemporaryValue = pqRxBuffer[0]; // bits 13..6
sqTemporaryValue = sqTemporaryValue << 6; // shift left to make room for bits 5..0
sqTemporaryValue2 = pqRxBuffer[1]; // bits 5..0 in the most significant spots
sqTemporaryValue2 = sqTemporaryValue2 >> 2; // shift right to get rid of extra bits and position
sqTemporaryValue |= sqTemporaryValue2; // Combine to get bits 13..0
if((pqRxBuffer[0] & 0x80) == 0x80) { // Check the sign bit and sign-extend if need be
sqTemporaryValue |= 0xFFFFE000;
}
fMAX31855_thermocouple_temp = (float)sqTemporaryValue / 4.0f;
pSystem->fThermocoupleTemperature = fMAX31855_thermocouple_temp;
}
return;
L_DIE:
return;
}
/*--------------------------------------------------------------------------------*/
static void StartSystem(System* pSystem)
{
XIic_Config *pI2cConfig;
XGpioPs_Config* pGpioConfig;
int iLen;
/*-----------------------------------------------------------------*/
pSystem->bError = 0;
pSystem->bBarometerOk = 0;
pSystem->bHygrometerOk = 0;
pSystem->bThermocoupleOk = 0;
pSystem->rc = XST_SUCCESS;
pSystem->pcErr = "\r\n";
pSystem->xMQTTHandle = NULL;
/*-----------------------------------------------------------------*/
MAY_DIE({
iLen = snprintf(
(char*)pSystem->pbSensorTopic,
SYSTEM_SENSOR_TOPIC_LENGTH+1,
"compressor/%s-gateway-ultra96/cooling_system/1",
clientcredentialGG_GROUP
);
if((iLen < 0) || (iLen > SYSTEM_SENSOR_TOPIC_LENGTH)) {
pSystem->pbSensorTopic[0] = 0;
pSystem->usSensorTopicLength = 0;
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Cannot compose system sensor topic: GroupID too long\r\n";
} else {
pSystem->pbSensorTopic[SYSTEM_SENSOR_TOPIC_LENGTH] = 0;
pSystem->usSensorTopicLength = (uint16_t)strlen((const char*)pSystem->pbSensorTopic);
}
});
MAY_DIE({
iLen = snprintf(
(char*)pSystem->pbShadowTopic,
SYSTEM_SHADOW_TOPIC_LENGTH+1,
"$aws/things/%s-gateway-ultra96/shadow/update",
clientcredentialGG_GROUP
);
if((iLen < 0) || (iLen > SYSTEM_SENSOR_TOPIC_LENGTH)) {
pSystem->pbShadowTopic[0] = 0;
pSystem->usShadowTopicLength = 0;
pSystem->rc = XST_FAILURE;
pSystem->pcErr = "Cannot compose system shadow topic: GroupID too long\r\n";
} else {
pSystem->pbShadowTopic[SYSTEM_SHADOW_TOPIC_LENGTH] = 0;
pSystem->usShadowTopicLength = (uint16_t)strlen((const char*)pSystem->pbShadowTopic);
}
});
/*-----------------------------------------------------------------*/
pGpioConfig = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID);
configASSERT(pGpioConfig != NULL);
MAY_DIE({
pSystem->rc = XGpioPs_CfgInitialize(&pSystem->gpio, pGpioConfig, pGpioConfig->BaseAddr);
pSystem->pcErr = "XGpioPs_CfgInitialize() -> 0x%08x\r\n";
});
XGpioPs_SetDirectionPin(&pSystem->gpio, LED_PIN, 1);
XGpioPs_SetOutputEnablePin(&pSystem->gpio, LED_PIN, 1);
BlinkLed(pSystem, 5, pdFALSE);
/*-----------------------------------------------------------------*/
pI2cConfig = XIic_LookupConfig(XPAR_IIC_0_DEVICE_ID);
configASSERT(pI2cConfig != NULL);
MAY_DIE({
pSystem->rc = XIic_CfgInitialize(&pSystem->iic, pI2cConfig, pI2cConfig->BaseAddress);
pSystem->pcErr = "XIic_CfgInitialize() -> 0x%08x\r\n";
});
XIic_IntrGlobalDisable(pI2cConfig->BaseAddress);
MAY_DIE({
pSystem->rc = XIic_Start(&pSystem->iic);
pSystem->pcErr = "XIic_Start() -> 0x%08x\r\n";
});
/*-----------------------------------------------------------------*/
/* Create the MQTT client object and connect it to the MQTT broker. */
MAY_DIE({
prvCreateClientAndConnectToBroker(pSystem);
if(XST_SUCCESS == pSystem->rc) {
BlinkLed(pSystem, 5, pdTRUE);
}
});
/*-----------------------------------------------------------------*/
/*
* Ignore system error, as each sensor has its own OK and will skip sampling
*/
StartBarometer(pSystem);
StartPLTempSensor(pSystem);
StartHygrometer(pSystem);
/*-----------------------------------------------------------------*/
configPRINTF( ( "System started\r\n" ) );
return;
/*-----------------------------------------------------------------*/
L_DIE:
StopSystem(pSystem);
}
static void StopSystem(System* pSystem)
{
if(NULL != pSystem->xMQTTHandle) {
prvPublishShadow(pSystem);
/* Disconnect the client. */
( void ) MQTT_AGENT_Disconnect( pSystem->xMQTTHandle, democonfigMQTT_TIMEOUT );
}
StopHygrometer(pSystem);
StopPLTempSensor(pSystem);
StopBarometer(pSystem);
if(pSystem->iic.IsReady) {
XIic_Stop(&pSystem->iic);
}
BlinkLed(pSystem, 5, pdFALSE);
/* End the demo by deleting all created resources. */
configPRINTF( ( "Sensor demo done.\r\n" ) );
vTaskDelete( NULL ); /* Delete this task. */
}
/*--------------------------------------------------------------------------------*/
static void prvUZedIotTask( void * pvParameters )
{
TickType_t xPreviousWakeTime;
const TickType_t xSamplingPeriod = MS_TO_TICKS( SAMPLING_PERIOD_MS );
u8 bFirst;
System* pSystem = &g_tSystem;
/* Avoid compiler warnings about unused parameters. */
( void ) pvParameters;
StartSystem(pSystem);
/* MQTT client is now connected to a broker. Publish or perish! */
/* Initialise the xLastWakeTime variable with the current time. */
xPreviousWakeTime = xTaskGetTickCount();
/*
* Ignore errors in loop and continue forever
*/
bFirst = 1;
for(;;) {
// Line up with next period boundary
vTaskDelayUntil( &xPreviousWakeTime, xSamplingPeriod );
// Publish all sensors
pSystem->bError = 0;
SampleBarometer(pSystem);
SamplePLTempSensor(pSystem);
SampleHygrometer(pSystem);
prvPublishSensors(pSystem);
if((pSystem->bLastReportedError != pSystem->bError) || bFirst) {
pSystem->bLastReportedError = pSystem->bError;
prvPublishShadow(pSystem);
}
bFirst = 0;
}
/* Not reached */
StopSystem(pSystem);
}
/*-----------------------------------------------------------*/
void vStartMQTTUZedIotDemo( void )
{
configPRINTF( ( "Creating UZedIot Task...\r\n" ) );
/*
* Create the task that publishes messages to the MQTT broker periodically
*/
( void ) xTaskCreate( prvUZedIotTask, /* The function that implements the demo task. */
"UZedIot", /* The name to assign to the task being created. */
democonfigMQTT_UZED_IOT_TASK_STACK_SIZE, /* The size, in WORDS (not bytes), of the stack to allocate for the task being created. */
NULL, /* The task parameter is not being used. */
democonfigMQTT_UZED_IOT_TASK_PRIORITY, /* The priority at which the task being created will run. */
NULL /* Not storing the task's handle. */
);
}
/*-----------------------------------------------------------*/
|
ayushev/aws-cloud-and-xilinx-workshop
|
zynq7k_demo/tests/xilinx/microzed/common/application_code/xilinx_code/hr_gettime.h
|
<reponame>ayushev/aws-cloud-and-xilinx-workshop
#ifndef HR_GETTIME_H
#define HR_GETTIME_H
void init_timer( int xTimer );
/* Start-up the high-resolution timer. */
void vStartHighResolutionTimer( void );
/* Get the current time measured in uS. */
unsigned long long ullGetHighResolutionTime( void );
#endif
|
dimarusyy/roster-display
|
src/fetchjson.h
|
<gh_stars>0
#pragma once
#include <QObject>
#include <QMetaType>
#include <QNetworkAccessManager>
#include <3rdparty/nlohmann/json.hpp>
Q_DECLARE_METATYPE(std::shared_ptr<nlohmann::json>)
class FetchJson : public QObject
{
Q_OBJECT
public:
static const QUrl defaultUrl;
explicit FetchJson(QObject *parent = nullptr);
void fetch(const QUrl&);
signals:
void failed(const QString& ec);
void succeeded(std::shared_ptr<nlohmann::json>);
public slots:
private:
std::unique_ptr<QNetworkAccessManager> _nam;
};
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.