»»»Home «««
»»»TELL «««
»»»Toped «««
»»»Ifaces «««


The OASIS format is a hardware/software independent binary file format designed to encapsulate hierarchical mask layout for interchange between systems such as EDA software, mask writing tools and mask inspection/repair tools.

The OASIS is a relatively new format described in SEMI P39-308 standard. It is gaining popularity quickly because of its efficiency. It can achieve at least an order of magnitude improvement of the file size over GDSII.

OASIS Layer Maps
The layer maps are presented in a form of lmap lists. They can be saved in a TELL variable and reused for import/export. The idea is that the user can interface with different technologies without redefining its Toped layers. Each member of the OASIS layer map is in the format described below. The format allows several OASIS layers to be converted to a single TDT layer. The same is valid for OASIS data types. The Toped data base doesn’t maintain the data type concept of OASIS. It has practically unlimited number of layers though. Using the layer map each OASIS layer / datatype pair can be mapped to a separate TDT layer and vice-versa.
[Tip]{tdt_lay, "oasis_layers : oasis_datatype"}
int tdt_lay
This is the key field of the lmap structure which contains the TDT layer number. That TDT layer will be the target layer for import operations and source layer during the export.

The value field consists of two parts separated by mandatory colon.

This string contains one or more OASIS layers in quick list format.
This string contains one or more OASIS datatypes in quick list format.

Example 1. oasis layer map

   lmap list oas_layer_definition = {{ 1, " 1; *"   }, { 2, " 2; 0"},
                                     { 3, " 3;20, 0"}, { 4, " 4; 0"},
                                     { 5, " 5; 0"   }, { 6, " 6; 0"},
                                     { 7, " 7; 0"   }, { 8, " 8; 0"},
                                     { 9, " 9; 0"   }, {10, "10; 0"},
                                     {60, "60;20"   }, {62, "60;40"} };

  • the * in the data type field of layer 1 will force all OASIS data types to be imported to a single TDT layer. On export the \* will be simply replaced by 0
  • A similar rule is valid for the layer 3. On import both OASIS data types 0 and 20 will be converted to TDT layer 3. On export only the first data type will be taken into account and all data on layer 3 will be converted to OASIS data type 20 in layer 3.

The rest of the list members should be trivial.


Parse an OASIS file - this is the first step of the two-step process of OASIS conversion. When executed this function parses the OASIS file into memory checking it for validity, hierarchy structure and used layers. The function returns a list of strings containing the names of the top-level structures in the parsed file. To convert OASIS structure into TDT, use oasisimport. When done, call oasisclose to free the memory occupied by this operation. Only one OASIS DB can reside in memory at a time. oasisread will automatically remove the previous OASIS database (if any) from the memory.

[Tip]string list oasisread(file_name)
string file_name
A valid file name - platform dependent. OS environmental variables may be used. Compressed files are accepted as well - zip and gz formats.

Example 2. oasisread

   string list top_s = oasisread("/home/guest_user/layout/new_design.oas");



Convert OASIS structure to TDT cell - this is the second step of the OASIS import process. Function requires that an OASIS file has been already parsed into the memory using oasisread. It transfers the data from the external format to the appropriate TDT types. It is important to note that this function does not replace an existingTDT database. Instead it simply adds new cells to the TDT. This is supposed to facilitate the work of transferring layout blocks from design to design. A TDT database is created only if it is not already existing.

[Tip]oasisimport …

void oasisimport (top_structures, layer_map, recursive, overwrite)

void oasisimport (top_structure, layer_map ,recursive, overwrite)

string list top_structures
A list of names of the top OASIS structures to be imported.
string list top_structure
The name of the top OASIS structure to be imported.
lmap list layer_map
The oasis_layer_map to be used during the conversion.
bool recursive
Defines recursive behavior of the function. If true, the function will convert all the structures referenced directly or indirectly by the top structures. If false only the top structure will be converted.
bool overwrite
Defines the overwrite policy. If true - the cells created by the conversion will overwrite the TDT cell with the same name (if they exists). If false, the existing OASIS cells will be preserved - i.e. OASIS cell will not be converted if a TDT cell with this name already exists.

Toped will import only the layers listed in the layer_map. The layers not listed there will be silently omitted. The function getoasislaymap can be used to obtain the default layer map of the parsed OASIS database.

Example 3. oasisimport

   oasisimport("top_structure", {{2,"2;*"},{4,"4;0"}}, true, false);
   oasisimport(oasisread("test_file.oas"), getoasislaymap(true), true, true);

In the first example above, current TDT layout database will be updated with the OASIS hierarchy starting with the cell named top_structure and only layers 2 and 4 with the corresponding data types will be converted. All existing TDT cells will be preserved.

The second example is demonstrating a quick way to get an external OASIS file imported into Toped.



Clean-up the memory from the OASIS data parsed with oasisread. After executing oasisclose, oasisimport can not be called until the next oasisread. It is important to use this function, when parsed OASIS database is no longer required.

[Tip]void oasisclose ()

Example 4. oasisclose




Prints the list of used layers in an OASIS structure. The function can be used only if there is an OASIS file parsed in the memory.

[Tip]layout report_oasislayers( struct_name )
string struct_name
Target structure name

This function always takes into account the layers used in the entire hierarchy of structures, starting from struct_name.

Example 5. report_oasislayers




Returns TDT-OASIS layer map suitable for use in the interface functions oasisimport and oasisexport. The function checks whether a layer map has been already saved in the memory (see setoasislaymap). It returns the saved map if it exists. If a map doesn’t exists in memory - the function generates a default layer map.

[Tip]lmap list getoasislaymap( import )
bool import
Import and export functions might have different requirements for the layer map especially when Toped generates the default layer map. This parameter brings the information about the purpose of the generated map. It must be set to true if the generated map is going to be used in oasisimport and false if it will be used in oasisexport.

If a default layer map can not be generated the function will issue an error on the log window. Depending on the input parameter this could be because a TDT or OASIS data base doesn’t exists in the memory.

Example 6. getoasislaymap

   lmap list oasisImportMap = getoasislaymap(true);
   oasisimport(oasisread("test_file.oas"), oasisImportMap, true, true);



Stores a TDT-OASIS layer map as a Toped property. The map can be later retrieved using getoasislaymap and is also used as an initial layer map in the OASIS import/export dialogue boxes. The map will be dumped along with other editor properties by propsave

[Tip]void setoasislaymap( layer_map )
lmap list layer_map
The oasis_layer_map to be saved as a Toped property.

Example 7. setoasislaymap

   lmap list oasisDefaultMap = {{2,"2;0"},{4,"4;0"},{60,"60;40"}};



Clean-up the memory from the layer map stored by setoasislaymap. After executing clearoasislaymap, getoasislaymap will return the default layer map.

[Tip]void clearoasislaymap ()

Example 8. clearoasislaymap