Get the system suffix, fix it and return it.
@return
773634
public static String getSystemSuffix(String suffix, String defaultSuffix)
    {
        if (defaultSuffix == null)
            defaultSuffix = DEFAULT_SYSTEM_SUFFIX;
        if (suffix == null)
            suffix = defaultSuffix;
        for (int i = suffix.length() - 2; i > 0; i--)
        {   // Only use last word
            if (!Character.isLetterOrDigit(suffix.charAt(i)))
            {
                suffix = suffix.substring(i + 1); // Typical to pass groupId
                break;
            }
        }
        return suffix;
    }
14122
private function getSuffixesToTry()
    {
        if ($this->suffixesToTry === null) {
            $this->suffixesToTry = [];

            if (isset($this->conf['salutation'])) {
                if ($this->conf['salutation'] === 'informal') {
                    $this->suffixesToTry[] = '_informal';
                }
                $this->suffixesToTry[] = '_formal';
            }
            $this->suffixesToTry[] = '';
        }

        return $this->suffixesToTry;
    }
1154335
public String getExpressionString() {
        StringBuffer buf = new StringBuffer();
        buf.append(mPrefix.getExpressionString());

        for (int i = 0; mSuffixes != null && i < mSuffixes.size(); i++) {
            ValueSuffix suffix = (ValueSuffix) mSuffixes.get(i);
            buf.append(suffix.getExpressionString());
        }

        return buf.toString();
    }
93881
@Override
  public String[] getFileSuffixes() {
    String[] suffixes = filterEmptyStrings(settings.getStringArray(GroovyPlugin.FILE_SUFFIXES_KEY));
    if (suffixes.length == 0) {
      suffixes = StringUtils.split(GroovyPlugin.DEFAULT_FILE_SUFFIXES, ",");
    }
    return addDot(suffixes);
  }
1347077
public String getDefaultSystemName()
    {   // No system name set, check the base menus for domain or default properties
        Environment env = this.getEnvironment();
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put(DBConstants.SYSTEM_NAME, "base");
        BaseApplication app = new MainApplication(env, properties, null);
        try {
            Task task = new AutoTask(app, null, properties);
            RecordOwner recordOwner = new BaseProcess(task, null, properties);
            Record menus = Record.makeRecordFromClassName(MenusModel.THICK_CLASS, recordOwner);
            menus.getField(Menus.CODE).setString(ResourceConstants.DEFAULT_RESOURCE);
            menus.setKeyArea(MenusModel.CODE_KEY);
            if (menus.seek(null))
                return ((PropertiesField)menus.getField(Menus.PARAMS)).getProperty(DBConstants.SYSTEM_NAME);
        } catch (DBException e) {
            e.printStackTrace();
        } finally {
            env.removeApplication(app);
            app.setEnvironment(null);
            app.free();
        }
        return Utility.DEFAULT_SYSTEM_SUFFIX;
    }
36129
static String getSafeSystemNewline() {
    try {
      String unsafeNewline = System.getProperty("line.separator");
      if (unsafeNewline.matches(ALLOWED_NEWLINE_PATTERN)) {
        return unsafeNewline;
      }
    } catch (SecurityException e) {
      // Fall through to default value;
    }
    return "\n";
  }
1271794
public String getNormalisedPrefix() {
        StringBuilder strBuilder = new StringBuilder();
        strBuilder.append(scheme).append("://").append(host);
        if (!isDefaultHttpOrHttpsPort(scheme, port)) {
            strBuilder.append(':').append(port);
        }
        if (path != null) {
            strBuilder.append(path);
        }
        return strBuilder.toString();
    }
1218599
private String suffix(final String line) {
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            if (c == ' ' || c == '\t') return line.substring(i + 1);
        }
        return "";
    }
147272
@Override
	public String getPrefix() {
		final String result = localPrefix.get();
		if (result == null) {
			return defaultPrefix;
		}
		return result;
	}
1027018
def _suffix(self):
        """"""
        _output_formats={'GCG':'.msf',
                        'GDE':'.gde',
                        'PHYLIP':'.phy',
                        'PIR':'.pir',
                        'NEXUS':'.nxs'}

        if self.Parameters['-output'].isOn():
            return _output_formats[self.Parameters['-output'].Value]
        else:
            return '.aln'
749351
private String getPrefix() {

        if (m_prefix == null) {
            m_prefix = OpenCms.getSystemInfo().getContextPath()
                + "/"
                + OpenCms.getStaticExportManager().getProtectedExportPath()
                + "/";
        }
        return m_prefix;
    }
414367
public int get(String suffix)
    {
        suffix = reverse(suffix);
        Integer length = trie.get(suffix);
        if (length == null) return 0;

        return length;
    }
694037
public String getEffectivePrefix() {
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			return getPrefix(new StringBuilder(), useLocalPrefixes).toString();
		} finally {
			lock.readLock().unlock();
		}
	}
30756
public String getPrefix()
  {
        int len=m_rawName.length()-m_localName.length()-1;
    return (len>0)
            ? m_rawName.substring(0,len)
            : "";
  }
853102
public String getFileSystemTypeLabel() {
        final StringBuilder sb = new StringBuilder(FILE_SYSTEM_TYPE_LENGTH);

        for (int i=0; i < FILE_SYSTEM_TYPE_LENGTH; i++) {
            sb.append ((char) get8(getFileSystemTypeLabelOffset() + i));
        }

        return sb.toString();
    }
709699
protected function getClassNameSuffix()
    {
        $suffix = $this->input->getOption('suffix');

        if (empty($suffix)) {
            $suffix = $this->classNameSuffix;
        }

        return $suffix;
    }
956090
def get_suffix(name):
    
    a = name.count(".")
    if a:
        ext = name.split(".")[-1]
        if ext in LANGS.keys():
            return ext
        return False
    else:
        return False