typedef struct
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 6
DataObjects.NET Express 3.8.8
DataObjects.NET is a useful and reliable .NET library which dramatically simplifies development of data more>>
DataObjects.NET is a useful and reliable .NET library which dramatically simplifies development of data and business tiers of the database application. It provides:
Methodology that standardizes and simplifies development of persistent classes and services operating with them providing very clear separation of your business and data tiers from other parts of an application. Essentially DataObjects.NET requires you to build a hierarchy of your persistent and business objects over two base classes: DataObject and DataService. It provides more then 20 attributes controlling almost any persistence or behavior-related aspect. Dont worry about this number - you can know nearly 5 of them to start using DataObjects.NET.
Persistence framework handling all object persistence related tasks transparently. Moreover, this framework allows to almost forget that the underlying database exists - it handles even database schema updates. This framework fully supports inheritance, persistent interfaces, relations and collections, object queries, full-text indexing and search, multilingual properties and a lot of other features. Use of this framework makes most part of your data tier automatically compatible with Microsoft SQL Server 2005 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) (free, but one of the most featured database servers) without any additional code.
Transactional services allowing to almost forget that your business and data objects operate in the concurrent transactional environment. Transactional services intercept calls of your business tier methods and wraps them into transactions (outermost or nested) providing that if exception or deadlock occurs, no data will be changed. These services are capable of re-processing method call on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless its highly configurable.
Security system supporting per-instance access control lists (allow-deny lists), permissions (custom permissions), security principals (users and roles) and permission inheritance. Its primary goal is to make usage of business objects completely safe, even when these objects are publicly available - via .NET Remoting, for example.
All is initially remotable - any persistent object or business service can be marshaled to another application domain via .NET Remoting (as well as all other DataObjects.NET-related objects, e.g. Query). This means that you can access your data and business tier from a completely different network or across the Internet with almost no additional code. DataObjects.NET supports two marshalling scenarios: access-by-reference for regular DataObjects and by-value marshalling for so-called offline entities (data transfer objects).
Main features:
- Transparent persistence: you dont need to write data access code for insertupdatedelete operations - DataObjects.NET persists instances transparently for you. This means that you should never think about invoking a SaveLoad-like methods also - DataObjects.NET handles such tasks completely transparently making you fell youre working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldnt worry about persisting your changes. Note that this doesnt mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
- Automatic database schema buildingupgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of Domain its database can be upgraded to support new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). Upgrade process doesnt destroy existing data.
- Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances; upcoming versions will support GUID and 32-bit integers also.
- Querying: use DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances youre interested in. An example of DataObjects.NET query: "Select Animal instances where {LegCount}=4 order by {Name}" - this query fetches all four-legged Animal instances, as well as instances of Animal descendants - e.g. Cats and Dogs). More difficult example selecting grandparents instances: "Select Animal instances where {Children[{Children.count}>0].count}>0". DataObjects.NET query language supports sub-queries, joins, distinct and full-text search part in criteria.
- Inheritance support: as it was mentioned, DataObjects.NET fully supports inheritance for persistent classes. But we went much further here: DataObjects.NET supports so-called persistent interfaces. This unique feature allows you to query for objects implementing some interface and refer to its persistent properties inside query criteria.
- Highly configurable persistence for instance properties:
- Multilingual properties (unique feature): you can mark any property with [Translatable] attribute to specify that it should store independent versions of its value for each Culture registered in you Domain. This and a set of other features dramatically simplifies development of multilingual database applications
- References: dont worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if youll try to delete the grandCat instance after executing this code, cat will be notified (because it holds a reference to grandCat). Also after grandCat deletion cat.Parent will be automatically set to null
- Collections: cat.Children.Add(kittyCat). Paired collections and reference properties (unique feature) are supported (so kittyCat.Parent can be automatically set to cat for the code above). "Contained" collections and references are supported as well (if cat.Children is marked by [Contained] attribute, all instances referenced by Children collection will be deleted on cats deletion)
- Structs: any struct type can be used as type of persistent property or item of collection. DataObjects.NET persists such properties into multiple database columns according to the structure of struct type.
- [Serializable] properties: properties which type is marked by [Serializable] attribute are persisted without any additional coding - theyre stored as byte streams (BLOBs). DataObjects.NET handles references to other persistent entities inside such serialized graphs in a special way making them to point to appropriate instances on each deserialization (note that DataObjects.NET is transactional, so you can find different versions of the same persistent instance in different sessions)
- SQL-related attributes are available for almost any type of persistent properties ([SqlType], [Length] and similar ones)
- Indexing: you can apply [Indexed] attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use [Index] attribute to describe a compound index
- Full-text indexing & search (unique feature): DataObjects.NET supports full-text indexing and search. Microsoft Search (available for SQL Server 20052000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. Built-in managed wrapper for Microsoft Index Service filters helps to index almost any documentfile type stored in database or externally. In particular, you can index the following document types: Microsoft Office files (.doc, .dot, .rtf, .xls, .ppt, etc...), HTML files (.htm, .html), Adobe PDF files and so on.
- Built-in NTFS-like security system (unique feature): DataObjects.NET has extremely powerful security system allowing to define the permission for any action (e.g. method execution or property access), grant or deny it for a set of security principals (users and roles) on some persistent instances (like on folders in NTFS) and enforce its presence by demanding it inside methods or property assessors of persistent types or DataServices. It brings NTFS-like security into your business tier with almost zero additional coding!
- We want to underline two very important features of this subsystem:
- Performance: security system is extremely fast - all passed permission demands are cached, effective permission sets for any cached DataObject instance are cached too, internal security notification layer allows any cached DataObject instance to notify all dependent cached instances on changes in its effective permission set... Normally a subsequent permission demand on the same instance is quite fast. This allows DataObjects.NET to execute up to 4000000 permission demands per second on 2,8GHz P4! Its almost impossible to implement a security system having the similar features and performance without implementing all other caching features DataObjects.NET has. Just imagine the nightmare of implementing the similar part in your DAL!
- Immediate effect: all security restrictions take effect immediately on any security-related changes in Session - so its not necessary to reopen Session invoke some method to apply new security restrictions. When you adding a User to some Role, granting permission for him or for some role it belongs to, this immediately affects on its security restrictions in the current Session - so all is transparent even in this case. Even rollback of nested transaction (or rollback to savepoint) immediately affects on security restrictions.
- Rich data import and export capabilities:
- Serialization: DataObjects.NET completely supports .NET Serialization, so you can serialize or deserialize a graph with persistent instances using binary or SOAP formatters. Custom formatters are supported as well.
- Adapter component exports persistent instances to DataSet and imports back the changes
- Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) pattern. It allows to export a set of DataObject instances to serializable, marshal-by-value ObjectSets, pass them to the client to operate with them locally and propagate the changes made to them back to the application server
- BindingManager component (unique feature) establishes two-way bindings between ASP.NETWindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings - we think this approach is also interesting for developers
- All importexport tools support VersionIDVersionCode validation (optimistic updates)
- Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if its turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 2000 driver only.
- Automatic transactions (unique feature - it quite differs from standard COM+ automatic transactions, read more about it further): DataObjects.NET is completely transactional. It supports automatic transactions (started with a method call or property access and committed or rolled back based on result; transactional behavior is controlled by attributes) as well as manual transactions (you can also start/commit/rollback a transaction manually); nested transactions and savepoints are also supported.
- Transparent deadlock handling (unique feature): in a highly concurrent environment deadlocks are regular. In case of a deadlock one of the deadlocked transactions (deadlock victim) is aborted by the database server. Normally it should be re-executed later by the application - this situation is called "deadlock handling". DataObjects.NET is capable of handling deadlocks transparently - if a deadlock occurs during an automatic transaction, it can be transparently handled by re-processing of the outermost transaction (re-calling of corresponding method).
- Data services (unique feature) allows to use all DataObjects.NET transactional capabilities (automatic transactions, transparent deadlock handling) with non-persistent classes (DataService descendants). This feature greatly simplifies development of services operating with persistent instances. Its very convenient to use this conception to develop common services of an application, such as Logging Service. Data services are very close to ServicedComponents of .NET, the difference is that they are much faster (method calls are intercepted by the runtime proxies rather then .NET transparent proxies, no COM+ services are used) and easier to use.
- Runtime services (unique feature) are data services of special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside Domain. The purpose of runtime services is to perform various maintenance tasks periodically. For example, all IFtIndexer implementors are runtime services that periodically update full-text indexes.
<<lessMethodology that standardizes and simplifies development of persistent classes and services operating with them providing very clear separation of your business and data tiers from other parts of an application. Essentially DataObjects.NET requires you to build a hierarchy of your persistent and business objects over two base classes: DataObject and DataService. It provides more then 20 attributes controlling almost any persistence or behavior-related aspect. Dont worry about this number - you can know nearly 5 of them to start using DataObjects.NET.
Persistence framework handling all object persistence related tasks transparently. Moreover, this framework allows to almost forget that the underlying database exists - it handles even database schema updates. This framework fully supports inheritance, persistent interfaces, relations and collections, object queries, full-text indexing and search, multilingual properties and a lot of other features. Use of this framework makes most part of your data tier automatically compatible with Microsoft SQL Server 2005 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) (free, but one of the most featured database servers) without any additional code.
Transactional services allowing to almost forget that your business and data objects operate in the concurrent transactional environment. Transactional services intercept calls of your business tier methods and wraps them into transactions (outermost or nested) providing that if exception or deadlock occurs, no data will be changed. These services are capable of re-processing method call on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless its highly configurable.
Security system supporting per-instance access control lists (allow-deny lists), permissions (custom permissions), security principals (users and roles) and permission inheritance. Its primary goal is to make usage of business objects completely safe, even when these objects are publicly available - via .NET Remoting, for example.
All is initially remotable - any persistent object or business service can be marshaled to another application domain via .NET Remoting (as well as all other DataObjects.NET-related objects, e.g. Query). This means that you can access your data and business tier from a completely different network or across the Internet with almost no additional code. DataObjects.NET supports two marshalling scenarios: access-by-reference for regular DataObjects and by-value marshalling for so-called offline entities (data transfer objects).
Main features:
- Transparent persistence: you dont need to write data access code for insertupdatedelete operations - DataObjects.NET persists instances transparently for you. This means that you should never think about invoking a SaveLoad-like methods also - DataObjects.NET handles such tasks completely transparently making you fell youre working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldnt worry about persisting your changes. Note that this doesnt mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
- Automatic database schema buildingupgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of Domain its database can be upgraded to support new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). Upgrade process doesnt destroy existing data.
- Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances; upcoming versions will support GUID and 32-bit integers also.
- Querying: use DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances youre interested in. An example of DataObjects.NET query: "Select Animal instances where {LegCount}=4 order by {Name}" - this query fetches all four-legged Animal instances, as well as instances of Animal descendants - e.g. Cats and Dogs). More difficult example selecting grandparents instances: "Select Animal instances where {Children[{Children.count}>0].count}>0". DataObjects.NET query language supports sub-queries, joins, distinct and full-text search part in criteria.
- Inheritance support: as it was mentioned, DataObjects.NET fully supports inheritance for persistent classes. But we went much further here: DataObjects.NET supports so-called persistent interfaces. This unique feature allows you to query for objects implementing some interface and refer to its persistent properties inside query criteria.
- Highly configurable persistence for instance properties:
- Multilingual properties (unique feature): you can mark any property with [Translatable] attribute to specify that it should store independent versions of its value for each Culture registered in you Domain. This and a set of other features dramatically simplifies development of multilingual database applications
- References: dont worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if youll try to delete the grandCat instance after executing this code, cat will be notified (because it holds a reference to grandCat). Also after grandCat deletion cat.Parent will be automatically set to null
- Collections: cat.Children.Add(kittyCat). Paired collections and reference properties (unique feature) are supported (so kittyCat.Parent can be automatically set to cat for the code above). "Contained" collections and references are supported as well (if cat.Children is marked by [Contained] attribute, all instances referenced by Children collection will be deleted on cats deletion)
- Structs: any struct type can be used as type of persistent property or item of collection. DataObjects.NET persists such properties into multiple database columns according to the structure of struct type.
- [Serializable] properties: properties which type is marked by [Serializable] attribute are persisted without any additional coding - theyre stored as byte streams (BLOBs). DataObjects.NET handles references to other persistent entities inside such serialized graphs in a special way making them to point to appropriate instances on each deserialization (note that DataObjects.NET is transactional, so you can find different versions of the same persistent instance in different sessions)
- SQL-related attributes are available for almost any type of persistent properties ([SqlType], [Length] and similar ones)
- Indexing: you can apply [Indexed] attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use [Index] attribute to describe a compound index
- Full-text indexing & search (unique feature): DataObjects.NET supports full-text indexing and search. Microsoft Search (available for SQL Server 20052000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. Built-in managed wrapper for Microsoft Index Service filters helps to index almost any documentfile type stored in database or externally. In particular, you can index the following document types: Microsoft Office files (.doc, .dot, .rtf, .xls, .ppt, etc...), HTML files (.htm, .html), Adobe PDF files and so on.
- Built-in NTFS-like security system (unique feature): DataObjects.NET has extremely powerful security system allowing to define the permission for any action (e.g. method execution or property access), grant or deny it for a set of security principals (users and roles) on some persistent instances (like on folders in NTFS) and enforce its presence by demanding it inside methods or property assessors of persistent types or DataServices. It brings NTFS-like security into your business tier with almost zero additional coding!
- We want to underline two very important features of this subsystem:
- Performance: security system is extremely fast - all passed permission demands are cached, effective permission sets for any cached DataObject instance are cached too, internal security notification layer allows any cached DataObject instance to notify all dependent cached instances on changes in its effective permission set... Normally a subsequent permission demand on the same instance is quite fast. This allows DataObjects.NET to execute up to 4000000 permission demands per second on 2,8GHz P4! Its almost impossible to implement a security system having the similar features and performance without implementing all other caching features DataObjects.NET has. Just imagine the nightmare of implementing the similar part in your DAL!
- Immediate effect: all security restrictions take effect immediately on any security-related changes in Session - so its not necessary to reopen Session invoke some method to apply new security restrictions. When you adding a User to some Role, granting permission for him or for some role it belongs to, this immediately affects on its security restrictions in the current Session - so all is transparent even in this case. Even rollback of nested transaction (or rollback to savepoint) immediately affects on security restrictions.
- Rich data import and export capabilities:
- Serialization: DataObjects.NET completely supports .NET Serialization, so you can serialize or deserialize a graph with persistent instances using binary or SOAP formatters. Custom formatters are supported as well.
- Adapter component exports persistent instances to DataSet and imports back the changes
- Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) pattern. It allows to export a set of DataObject instances to serializable, marshal-by-value ObjectSets, pass them to the client to operate with them locally and propagate the changes made to them back to the application server
- BindingManager component (unique feature) establishes two-way bindings between ASP.NETWindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings - we think this approach is also interesting for developers
- All importexport tools support VersionIDVersionCode validation (optimistic updates)
- Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if its turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 2000 driver only.
- Automatic transactions (unique feature - it quite differs from standard COM+ automatic transactions, read more about it further): DataObjects.NET is completely transactional. It supports automatic transactions (started with a method call or property access and committed or rolled back based on result; transactional behavior is controlled by attributes) as well as manual transactions (you can also start/commit/rollback a transaction manually); nested transactions and savepoints are also supported.
- Transparent deadlock handling (unique feature): in a highly concurrent environment deadlocks are regular. In case of a deadlock one of the deadlocked transactions (deadlock victim) is aborted by the database server. Normally it should be re-executed later by the application - this situation is called "deadlock handling". DataObjects.NET is capable of handling deadlocks transparently - if a deadlock occurs during an automatic transaction, it can be transparently handled by re-processing of the outermost transaction (re-calling of corresponding method).
- Data services (unique feature) allows to use all DataObjects.NET transactional capabilities (automatic transactions, transparent deadlock handling) with non-persistent classes (DataService descendants). This feature greatly simplifies development of services operating with persistent instances. Its very convenient to use this conception to develop common services of an application, such as Logging Service. Data services are very close to ServicedComponents of .NET, the difference is that they are much faster (method calls are intercepted by the runtime proxies rather then .NET transparent proxies, no COM+ services are used) and easier to use.
- Runtime services (unique feature) are data services of special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside Domain. The purpose of runtime services is to perform various maintenance tasks periodically. For example, all IFtIndexer implementors are runtime services that periodically update full-text indexes.
Download (26.2MB)
Added: 2006-09-29 License: Freeware Price:
1428 downloads
AsmVars 1.01
This program is designed to scan assembly language projects for unreferenced local and global variables more>>
This program is designed to scan assembly language projects for unreferenced local and global variables and unreferenced procedures and labels.
ASMVARS can be provided a list of files on the command line, or can read a list of files from a list file (prefixed with @). All files provided to ASMVARS are treated as a single project. Wildcards are not accepted. The -v switchs puts ASMVARS into verbose mode.
ASMVARS automatically includes files indicated by include xxx statements in the source code.
Furthermore, ASMVARS automatically picks up on UNION and STRUCT datatypes that are defined in the source and also handles subsequent EQUs on those datatypes.
However, if you wish to manually specify datatypes then you can supply ASMVARS with a datatypes list file by prefixing that filename with !.
<<lessASMVARS can be provided a list of files on the command line, or can read a list of files from a list file (prefixed with @). All files provided to ASMVARS are treated as a single project. Wildcards are not accepted. The -v switchs puts ASMVARS into verbose mode.
ASMVARS automatically includes files indicated by include xxx statements in the source code.
Furthermore, ASMVARS automatically picks up on UNION and STRUCT datatypes that are defined in the source and also handles subsequent EQUs on those datatypes.
However, if you wish to manually specify datatypes then you can supply ASMVARS with a datatypes list file by prefixing that filename with !.
Download (31.7KB)
Added: 2006-11-11 License: Freeware Price:
1077 downloads
Pawn 3.3.4097
An embedded scripting language, specifically designed to extend applications and embedded systems. Features include a small footprint, quick execution of the P-code and a good interface to native functions. Full source code is included. more>>
Pawn 3.3.4097 is a simple, typeless, 32-bit extension language with a C-like syntax. A pawn "source" program is compiled to a binary file for optimal execution speed.
The pawn compiler outputs P-code (or bytecode) that subsequently runs on an abstract machine. Execution speed, stability, simplicity and a small footprint were essential design criteria for both the language and the abstract machine.
Features include a small footprint, inherent support for automatons or "state machines", quick execution of the P-code and a good interface to "native" functions. These features make Pawn a good scripting language for games, multimedia applications and embedded software (for which scripting is needed). Optimized P-code ("bytecode") interpreter in assembler (Windows & Linux); there is even a JIT for Windows and Linux. Full source code is included. Pawn was formerly called the "Small" language.
Major Features:
- Language features
- Pawn is a deterministic language: it will run at the same speed every launch --there is no garbage collector that kicks in. The compiler can estimate the memory footprint for the script (unless the script contains a recursive procedure), and that memory footprint is fixed and stable as well.
- The pawn language is derived from C, and in some ways I have tried to "fix" syntaxes of what I see as counter-intuitive or error-prone in the C language. The cases in a "switch" statement are not fall through, for example.
- Pawn supports pass-by-value (like C) and pass-by-reference for function arguments.
- Pawn supports default function arguments, for arrays and simple variables. The arguments with a default value do not have to be at the end of the argument list.
- Pawn supports named parameters together with the conventional positional parameters.
- Pawn supports states and automatons (state machines) directly in the language, including state-local variables. Doing this in the compiler allows for flexibility and optimal performance, as well as having the compiler verify the constraints of the automaton.
- Pawn has no "struct"s, but it extends arrays so that it can mimic light-weight structures with arrays; as an example of those extensions, pawn supports array assignment and array indices can be "tag checked".
- Array sizes are deterministic, but array declaration is flexible. All dimensions in a multi-dimensional table may be variable size, for example.
- Pawn supports symbolic constants, conditional compilation and assertions, as well as text substitution via a kind of "pre-processor". The advantage of unifying the pre-processor with the compiler is that the "#if" knows about "enum"s (which is not the case in standard C: "#if" is a pre-processor command, "enum" is a C construct).
- If you want to say that something costs 3 Euro, you might write "printf("price 2003 ");" in C (where octal 200 is decimal 128, which is the position in the updated ANSI character set that the Euro symbol resides in). This works for 8-bit characters, but what about 16-bit/32-bit Unicode/UCS-4 characters? In pawn, the numeric character code is optionally explicitly terminated with a semicolon, just to avoid this problem. So in pawn, you would write: "printf("price 128;3 ");" (in pawn, numeric character codes are in decimal, rather than octal). This is just one example of those little and minor annoyances that exist in C/C++ and that pawn addresses.
- With packed and unpacked strings, pawn is able to bridge ASCII and Unicode subsystems. The compiler accepts source files in 8-bit ASCII and UTF-8. When running in ASCII mode, the compiler can translate extended ASCII characters to Unicode, based on codepage tables --this even works for MBCS codepages.
- Like in C++, variable declarations may occur at any position where a statement is valid, as well as in the first expression of a "for" statement. pawn supports block local static variables, as well as the common local and global variables.
- The integer division and modulus operators ("/" and "%") are well defined for negative operands, unlike C (ISO C89) and C++. The ISO C99 standard (finally) defines "truncated division" as standard; Java also uses truncated division. pawn uses "floored division", as defined by Donald Knuth and as is also used by Haskell and Python.
- Toolkit features
- Pawn comes with an implementation of an abstract machine in portable C. The abstract machine is a set of C functions that you can easily link to an application or function library. By compiling the source code to P-code for an abstract machine (or "virtual machine"), pawn is much faster than pure interpreters.
- Pawn is certainly among the fastest of the scripting languages, especially when using an abstract machine in hand-crafted optimized assembler or a JIT. These optimized abstract machines are not very portable, but versions for Windows, Linux (running on x86 architecture) and ARM7 processors exist.
- The abstract machine for pawn lends itself well for embedding: the abstract machine has low overhead and multiple abstract machines may run concurrently in a process; the interface to native functions (in C/C++) is flexible and also has low overhead; no components other than a few functions from the standard C library are required to build the abstract machine. The abstract machine does not require dynamic memory allocation (or grabage collection) or file I/O. The abstract machine itself is ROM-able and it requires very little RAM.
- For memory-constrained devices, pawn scripts can run directly from ROM. Alternatively, pawn has compiler support for "code overlays" where chunks of code are read from a storage (for example a SD/MMC card, or Flash ROM) on an as-needed basis.
- For a little language, the pawn compiler has a pretty good error system. I dare to compare it with commercial level C/C++ compilers with all warnings enabled.
- Although the debugger for the pawn abstract machine is primitive, it is an order of magnitude better than the "printf" style of debugging that is so common for little languages.
- For a little language, I would also say that pawn is nicely documented. Many people learn by example, so the July 2004 edition of the "Language Guide" contains 17 complete pawn programs that cover a variety of topics and 21 pawn code snippets that form complete functions. Various extension modules come with their own documentation with more example programs. The "Implementers Guide" contains 10 C/C++ code snippets (for embedding the abstract machine in your application) that build a complete program (with various options) when put together. pawn is also one of the very few scripting languages that documents the abstract machine: the pseudo-instructions, memory layout and pseudo-registers.
- Pawn is a 32-bit language (even when compiled with 16-bit DOS tools), you can also compile it as a 64-bit language. It runs on 16-bit platforms (either DOS or an "embedded" platform) without problem.
- The security model of pawn is based on the robusteness of the tools and on execution of the P-code in a "sandbox" environment. There is a caveat: native functions (provided by the host application or executing environment) can do anything; the implementer of such native functions should address the appropriate security issues.
Enhancements: Bug fixes and minor enhancements.
WareSeeker Editor
<<less Download (4.11MB)
Added: 2009-04-09 License: Freeware Price: $0.00
863 downloads
Free D-softs DB Compare 1.31
DBC ensuring your applications dont fail due to a missing database structure object DBC (Database Compare) is a fast, comprehensive database struct... more>> <<less
Download (6292KB)
Added: 2008-09-07 License: Freeware Price: Free
416 downloads
Libcurl.NET 1.3
libcurl.NET Internet Client API . more>> LibCurlNet.chm contains documentation in MSDN format. The file
LibCurlNet.ndoc is the documentation file used by NDOC to
generate LibCurlNet.chm.
Description
Curl Top-level class for initialization and cleanup.
CurlForms This trivial class wraps the internal curl_forms struct.
Easy Implements the curl_easy_xxx API.
Multi Implements the curl_multi_xxx API.
MultiInfo Wraps the cURL struct CURLMsg. This class provides status information following a Multi transfer.
MultiPartForm Wraps a section of multipart form data to be submitted via the CURLOPT_HTTPPOST option in the SetOpt member of the Easy class.
Share This class provides an infrastructure for serializing access to data shared by multiple Easy objects, including cookie data and DNS hosts. It implements the curl_share_xxx API.<<less
Download (677KB)
Added: 2008-06-13 License: Freeware Price: Free
585 downloads
cc65 2.11.0.1
A complete cross development package for 65(C)02 systems, including a powerful macro assembler, a C compiler, linker, librarian more>>
A complete cross development package for 65(C)02 systems, including a powerful macro assembler, a C compiler, linker, librarian cc65 is based on a C compiler that was originally adapted for the Atari 8bit computers by John R. Dunning. The original C compiler is a Small C descendant but has several extensions, and some of the limits of the original Small C compiler are gone.
The complete package consists of the compiler, an assembler, a librarian, a linker, and a C library for the Atari. There are some packages on the net that claim to be adapted as a crosscompiler for DOS or Unix, but was not able to get them working correctly.
Because I wanted a C compiler for my CBM machines, I took the Atari compiler and started a rewrite. Until today, I have rewritten large parts of the compiler, all of the library, completely replaced the assembler, the linker and the librarian, and added a frontend to simplify use. All changes have been done with portability in mind, so porting to new 6502 architectures should be quite easy.
The compiler is almost ISO C compatible, so you should be able to translate many sources from other systems.
There may be other target system dependent limitations. One example is file I/O, which is not implemented on all platforms. This is no technical limitation (as with the stuff mentioned above) but does just mean that no one cared enough to write the actual code.
The compiler is only one of the tools available in this package. The assembler suite (assembler, linker, archiver) is a complete development environment for itself, that may be used to write programs for any 6502 machine. C code and assembler code may be used together and may call each other.
The assembler is a one pass macroassembler and is able to output code for the 6502, 65SC816 and the 65SC02. It has a lot of nifty features like include files, macros, conditional assembly, nested lexical levels (that is, local symbols), and more.
The assembler creates object files containing relocatable code. These files must be run through a linker to create the final program.
The linker has a flexible output format and is able to support ROMable code (different load and run addresses for data), banked systems (segments may share the same run address), systems with multiple ROMs, unlimited segments, more than one BSS segment and lots of other things.
The archiver is used to create libraries containing objects files. This simplifies code management. The linker will extract only those modules from a library that are actually needed.
To simplifiy use, there is also a frontend to the tools contained in the cc65 package. The frontend is named cl65. It knows how to build binaries from a list of C files, assembler files, object files and libraries. For smaller projects, just one invocation of the cl65 utility is needed to build a binary from several source files and libraries.
The runtime library and the standard C library have been designed with portability in mind. Changes for any 6502 system shouldnt be necessary. If you have a system not listed below, all you need is a new startup code.
Direct library support (that is, startup/initialization code) and support libraries for other features are available for:
- Commodore C64
- GEOS operating system for the Commodore C64
- Commodore C128
- Commodore C16, C116 and Plus/4
- Commodore P500
- Commodore 600/700 family of computers
- Apple ][
- Atari 8bit machines
- Oric Atmos
- Nintendo Entertainment System (NES)
- Supervision Game Console
- Atari Lynx Console
Main features:
- The compiler allows single line comments that start with //. This feature is disabled in strict ANSI mode.
- The compiler allows unnamed parameters in parameter lists. The compiler will not issue warnings about unused parameters that dont have a name. This feature is disabled in strict ANSI mode.
- The compiler has some additional keywords that are needed for special features. In strict ANSI mode, the additional keywords start with two underscores.
- The volatile modifier has no effect.
- The datatypes float and double are not available.
- The compiler does not support bit fields.
- C functions may not return structs and structs may not be passed as parameters by value. Struct assignment is possible.
- There are some limitation on the size of local variables. Not all operations are available if the size of local variables exceeds 256 bytes.
- Part of the C library is available only with fastcall calling conventions (see below). This means, that you may not mix pointers to those functions with pointers to user written functions.
<<lessThe complete package consists of the compiler, an assembler, a librarian, a linker, and a C library for the Atari. There are some packages on the net that claim to be adapted as a crosscompiler for DOS or Unix, but was not able to get them working correctly.
Because I wanted a C compiler for my CBM machines, I took the Atari compiler and started a rewrite. Until today, I have rewritten large parts of the compiler, all of the library, completely replaced the assembler, the linker and the librarian, and added a frontend to simplify use. All changes have been done with portability in mind, so porting to new 6502 architectures should be quite easy.
The compiler is almost ISO C compatible, so you should be able to translate many sources from other systems.
There may be other target system dependent limitations. One example is file I/O, which is not implemented on all platforms. This is no technical limitation (as with the stuff mentioned above) but does just mean that no one cared enough to write the actual code.
The compiler is only one of the tools available in this package. The assembler suite (assembler, linker, archiver) is a complete development environment for itself, that may be used to write programs for any 6502 machine. C code and assembler code may be used together and may call each other.
The assembler is a one pass macroassembler and is able to output code for the 6502, 65SC816 and the 65SC02. It has a lot of nifty features like include files, macros, conditional assembly, nested lexical levels (that is, local symbols), and more.
The assembler creates object files containing relocatable code. These files must be run through a linker to create the final program.
The linker has a flexible output format and is able to support ROMable code (different load and run addresses for data), banked systems (segments may share the same run address), systems with multiple ROMs, unlimited segments, more than one BSS segment and lots of other things.
The archiver is used to create libraries containing objects files. This simplifies code management. The linker will extract only those modules from a library that are actually needed.
To simplifiy use, there is also a frontend to the tools contained in the cc65 package. The frontend is named cl65. It knows how to build binaries from a list of C files, assembler files, object files and libraries. For smaller projects, just one invocation of the cl65 utility is needed to build a binary from several source files and libraries.
The runtime library and the standard C library have been designed with portability in mind. Changes for any 6502 system shouldnt be necessary. If you have a system not listed below, all you need is a new startup code.
Direct library support (that is, startup/initialization code) and support libraries for other features are available for:
- Commodore C64
- GEOS operating system for the Commodore C64
- Commodore C128
- Commodore C16, C116 and Plus/4
- Commodore P500
- Commodore 600/700 family of computers
- Apple ][
- Atari 8bit machines
- Oric Atmos
- Nintendo Entertainment System (NES)
- Supervision Game Console
- Atari Lynx Console
Main features:
- The compiler allows single line comments that start with //. This feature is disabled in strict ANSI mode.
- The compiler allows unnamed parameters in parameter lists. The compiler will not issue warnings about unused parameters that dont have a name. This feature is disabled in strict ANSI mode.
- The compiler has some additional keywords that are needed for special features. In strict ANSI mode, the additional keywords start with two underscores.
- The volatile modifier has no effect.
- The datatypes float and double are not available.
- The compiler does not support bit fields.
- C functions may not return structs and structs may not be passed as parameters by value. Struct assignment is possible.
- There are some limitation on the size of local variables. Not all operations are available if the size of local variables exceeds 256 bytes.
- Part of the C library is available only with fastcall calling conventions (see below). This means, that you may not mix pointers to those functions with pointers to user written functions.
Download (680KB)
Added: 2007-08-02 License: Freeware Price:
817 downloads
Secleted [ 0 ] software to compare
- Page: 1 of 1
- 1
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above typedef struct search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
